// **********************************************************************//// Copyright (c) 2003-2005 ZeroC, Inc. All rights reserved.//// This copy of Ice is licensed to you under the terms described in the// ICE_LICENSE file included in this distribution.//// **********************************************************************#include <ChatSessionI.h>#include <IceStorm/IceStorm.h>#include <IceUtil/UUID.h>#include <Chat.h>#include <list>using namespace std;using namespace Ice;using namespace Chat;using namespace Glacier2;class RoomManager;typedef IceUtil::Handle<RoomManager> RoomManagerPtr;class RoomManager : public IceUtil::Shared, public IceUtil::Mutex{public:    static RoomManagerPtr& instance();    ~RoomManager();    void initialize(const CommunicatorPtr&);    void destroy();    ChatRoomObserverPrx enter(const string&, const ChatRoomObserverPrx&);    void leave(const string&, const ChatRoomObserverPrx&);private:    IceStorm::TopicManagerPrx _manager;    map<string, IceStorm::TopicPrx> _rooms;    static RoomManagerPtr _instance;    static IceUtil::StaticMutex _instanceMutex;};typedef IceUtil::Handle<RoomManager> RoomManagerPtr;class ChatRoomParticipantI : public ChatRoomParticipant{public:    ChatRoomParticipantI(const string&, const string&, const ChatRoomObserverPrx&);    ~ChatRoomParticipantI();    virtual void say(const string&, const Current&);private:    const string _room;    const string _userId;    const ChatRoomObserverPrx _observer;    const ChatRoomObserverPrx _publish;};class ChatSessionI : public ChatSession, public IceUtil::Mutex{public:    ChatSessionI(const string&);    virtual ChatRoomParticipantPrx join(const string&, const ChatRoomObserverPrx&, const Current&);    virtual void destroy(const Current&);private:    const string _userId;    list<ChatRoomParticipantPrx> _rooms;};RoomManagerPtr RoomManager::_instance;IceUtil::StaticMutex RoomManager::_instanceMutex = ICE_STATIC_MUTEX_INITIALIZER;RoomManagerPtr&RoomManager::instance(){    IceUtil::StaticMutex::Lock sync(_instanceMutex);    if(!_instance)    {	_instance = new RoomManager;    }    return _instance;}RoomManager::~RoomManager(){}voidRoomManager::initialize(const CommunicatorPtr& communicator){    Lock sync(*this);    assert(!_manager);    string proxy = communicator->getProperties()->getProperty("IceStorm.TopicManager.Proxy");    _manager  = IceStorm::TopicManagerPrx::checkedCast(communicator->stringToProxy(proxy));    assert(_manager);}voidRoomManager::destroy(){    Lock sync(*this);    _manager = 0;    _rooms.clear();}ChatRoomObserverPrxRoomManager::enter(const string& room, const ChatRoomObserverPrx& observer){    Lock sync(*this);    assert(_manager);    map<string, IceStorm::TopicPrx>::const_iterator p = _rooms.find(room);    IceStorm::TopicPrx topic;    if(p == _rooms.end())    {	try	{	    topic = _manager->create(room);	}	catch(const IceStorm::TopicExists&)	{	    topic = _manager->retrieve(room);	}	assert(topic);	_rooms.insert(make_pair(room, topic));    }    else    {	topic = p->second;    }    topic->subscribe(IceStorm::QoS(), observer);    Context context;    context["_fwd"] = "Oz";    return ChatRoomObserverPrx::uncheckedCast(topic->getPublisher()->ice_newContext(context));}voidRoomManager::leave(const string& room, const ChatRoomObserverPrx& observer){    Lock sync(*this);    map<string, IceStorm::TopicPrx>::iterator p = _rooms.find(room);    if(p != _rooms.end())    {	p->second->unsubscribe(observer);    }}ChatRoomParticipantI::ChatRoomParticipantI(    const string& room, const string& userId, const ChatRoomObserverPrx& observer) :    _room(room),    _userId(userId),    _observer(observer),    _publish(RoomManager::instance()->enter(room, observer)){    _publish->message(_userId + " has entered the chat room.");}ChatRoomParticipantI::~ChatRoomParticipantI(){    try    {	RoomManager::instance()->leave(_room, _observer);	_publish->message(_userId + " has left the chat room.");    }    catch(...)    {	// Ignore. The ice mediated invocation can throw an	// exception on shutdown.    }}voidChatRoomParticipantI::say(const string& data, const Current&){    _publish->message(_userId + " says: " + data);}ChatSessionI::ChatSessionI(const string& userId) :    _userId(userId){}ChatRoomParticipantPrxChatSessionI::join(const string& room, const ChatRoomObserverPrx& observer, const Current& current){    Lock sync(*this);        Identity id;    id.category = "_" + _userId;    id.name = IceUtil::generateUUID();        ChatRoomParticipantPrx proxy = ChatRoomParticipantPrx::uncheckedCast(	current.adapter->add(new ChatRoomParticipantI(room, _userId, observer), id));    _rooms.push_back(proxy);    return proxy;}voidChatSessionI::destroy(const Current& current){    Lock sync(*this);        current.adapter->remove(current.id);    for(list<ChatRoomParticipantPrx>::const_iterator p = _rooms.begin(); p != _rooms.end(); ++p)    {	current.adapter->remove((*p)->ice_getIdentity());    }    _rooms.clear();}ChatSessionManagerI::ChatSessionManagerI(const CommunicatorPtr& communicator){    RoomManager::instance()->initialize(communicator);}ChatSessionManagerI::~ChatSessionManagerI(){    //    // Destroy the RoomManager state, otherwise proxies exist after    // the communicator is destroyed which results in warnings.    //    RoomManager::instance()->destroy();}SessionPrxChatSessionManagerI::create(const string& userId, const Current& current){    Identity id;    id.category = "_" + userId;    id.name = IceUtil::generateUUID();    return Glacier2::SessionPrx::uncheckedCast(	current.adapter->add(new ChatSessionI(userId), id));}