chatsessioni.cpp

一个icestorm的例子.ice是一个开源的中间件,性能好,易使用

// **********************************************************************
//
// 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()
{
}

void
RoomManager::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);
}

void
RoomManager::destroy()
{
    Lock sync(*this);
    _manager = 0;
    _rooms.clear();
}

ChatRoomObserverPrx
RoomManager::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));
}

void
RoomManager::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.
    }
}

void
ChatRoomParticipantI::say(const string& data, const Current&)
{
    _publish->message(_userId + " says: " + data);
}


ChatSessionI::ChatSessionI(const string& userId) :
    _userId(userId)
{
}

ChatRoomParticipantPrx
ChatSessionI::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;
}

void
ChatSessionI::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();
}

SessionPrx
ChatSessionManagerI::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));
}