Events.ice.C

// **********************************************************************
//
// Copyright (c) 2003-2009 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.
//
// **********************************************************************

// Ice version 3.3.1
// Generated from file `Events.ice'

#include <Events.ice.H>
#include <Ice/LocalException.h>
#include <Ice/ObjectFactory.h>
#include <Ice/BasicStream.h>
#include <IceUtil/Iterator.h>
#include <IceUtil/ScopedArray.h>

#ifndef ICE_IGNORE_VERSION
#   if ICE_INT_VERSION / 100 != 303
#       error Ice version mismatch!
#   endif
#   if ICE_INT_VERSION % 100 > 50
#       error Beta header file detected
#   endif
#   if ICE_INT_VERSION % 100 < 1
#       error Ice patch level mismatch!
#   endif
#endif

static const ::std::string __EventsNS__Events__evolve_name = "evolve";

::Ice::Object* IceInternal::upCast(::EventsNS::Event* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::EventsNS::Event* p) { return p; }

::Ice::Object* IceInternal::upCast(::EventsNS::Message1* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::EventsNS::Message1* p) { return p; }

::Ice::Object* IceInternal::upCast(::EventsNS::Message2* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::EventsNS::Message2* p) { return p; }

::Ice::Object* IceInternal::upCast(::EventsNS::Events* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::EventsNS::Events* p) { return p; }

::Ice::Object* IceInternal::upCast(::TestPub::Publisher1* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::TestPub::Publisher1* p) { return p; }

::Ice::Object* IceInternal::upCast(::TestPub::Publisher2* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::TestPub::Publisher2* p) { return p; }

::Ice::Object* IceInternal::upCast(::TestPub::Subscriber1* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::TestPub::Subscriber1* p) { return p; }

::Ice::Object* IceInternal::upCast(::TestPub::Subscriber2* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::TestPub::Subscriber2* p) { return p; }

void
EventsNS::__read(::IceInternal::BasicStream* __is, ::EventsNS::EventPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::EventsNS::Event;
        v->__copyFrom(proxy);
    }
}

void
EventsNS::__read(::IceInternal::BasicStream* __is, ::EventsNS::Message1Prx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::EventsNS::Message1;
        v->__copyFrom(proxy);
    }
}

void
EventsNS::__read(::IceInternal::BasicStream* __is, ::EventsNS::Message2Prx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::EventsNS::Message2;
        v->__copyFrom(proxy);
    }
}

void
EventsNS::__read(::IceInternal::BasicStream* __is, ::EventsNS::EventsPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::EventsNS::Events;
        v->__copyFrom(proxy);
    }
}

void
TestPub::__read(::IceInternal::BasicStream* __is, ::TestPub::Publisher1Prx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::TestPub::Publisher1;
        v->__copyFrom(proxy);
    }
}

void
TestPub::__read(::IceInternal::BasicStream* __is, ::TestPub::Publisher2Prx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::TestPub::Publisher2;
        v->__copyFrom(proxy);
    }
}

void
TestPub::__read(::IceInternal::BasicStream* __is, ::TestPub::Subscriber1Prx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::TestPub::Subscriber1;
        v->__copyFrom(proxy);
    }
}

void
TestPub::__read(::IceInternal::BasicStream* __is, ::TestPub::Subscriber2Prx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::TestPub::Subscriber2;
        v->__copyFrom(proxy);
    }
}

bool
EventsNS::AMI_Events_evolve::__invoke(const ::EventsNS::EventsPrx& __prx, const ::EventsNS::EventPtr& e, const ::Ice::Context* __ctx)
{
    __acquireCallback(__prx);
    try
    {
        __prepare(__prx, __EventsNS__Events__evolve_name, ::Ice::Normal, __ctx);
        __os->write(::Ice::ObjectPtr(::IceInternal::upCast(e.get())));
        __os->writePendingObjects();
        __os->endWriteEncaps();
        return __send();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __releaseCallback(__ex);
        return false;
    }
}

void
EventsNS::AMI_Events_evolve::__response(bool __ok)
{
    try
    {
        if(!__ok)
        {
            try
            {
                __throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
            }
            return;
        }
        __is->skipEmptyEncaps();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __finished(__ex);
        return;
    }
    ice_response();
    __releaseCallback();
}

const ::std::string&
IceProxy::EventsNS::Event::ice_staticId()
{
    return ::EventsNS::Event::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::EventsNS::Event::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::EventsNS::Event);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::EventsNS::Event::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::EventsNS::Event);
}

::IceProxy::Ice::Object*
IceProxy::EventsNS::Event::__newInstance() const
{
    return new Event;
}

const ::std::string&
IceProxy::EventsNS::Message1::ice_staticId()
{
    return ::EventsNS::Message1::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::EventsNS::Message1::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::EventsNS::Message1);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::EventsNS::Message1::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::EventsNS::Message1);
}

::IceProxy::Ice::Object*
IceProxy::EventsNS::Message1::__newInstance() const
{
    return new Message1;
}

const ::std::string&
IceProxy::EventsNS::Message2::ice_staticId()
{
    return ::EventsNS::Message2::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::EventsNS::Message2::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::EventsNS::Message2);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::EventsNS::Message2::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::EventsNS::Message2);
}

::IceProxy::Ice::Object*
IceProxy::EventsNS::Message2::__newInstance() const
{
    return new Message2;
}

void
IceProxy::EventsNS::Events::evolve(const ::EventsNS::EventPtr& e, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
            IceUtil::DummyBCC dummy;
#endif
            __delBase = __getDelegate(false);
            ::IceDelegate::EventsNS::Events* __del = dynamic_cast< ::IceDelegate::EventsNS::Events*>(__delBase.get());
            __del->evolve(e, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

bool
IceProxy::EventsNS::Events::evolve_async(const ::EventsNS::AMI_Events_evolvePtr& __cb, const ::EventsNS::EventPtr& e)
{
    return __cb->__invoke(this, e, 0);
}

bool
IceProxy::EventsNS::Events::evolve_async(const ::EventsNS::AMI_Events_evolvePtr& __cb, const ::EventsNS::EventPtr& e, const ::Ice::Context& __ctx)
{
    return __cb->__invoke(this, e, &__ctx);
}

const ::std::string&
IceProxy::EventsNS::Events::ice_staticId()
{
    return ::EventsNS::Events::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::EventsNS::Events::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::EventsNS::Events);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::EventsNS::Events::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::EventsNS::Events);
}

::IceProxy::Ice::Object*
IceProxy::EventsNS::Events::__newInstance() const
{
    return new Events;
}

const ::std::string&
IceProxy::TestPub::Publisher1::ice_staticId()
{
    return ::TestPub::Publisher1::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::TestPub::Publisher1::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::TestPub::Publisher1);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::TestPub::Publisher1::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::TestPub::Publisher1);
}

::IceProxy::Ice::Object*
IceProxy::TestPub::Publisher1::__newInstance() const
{
    return new Publisher1;
}

const ::std::string&
IceProxy::TestPub::Publisher2::ice_staticId()
{
    return ::TestPub::Publisher2::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::TestPub::Publisher2::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::TestPub::Publisher2);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::TestPub::Publisher2::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::TestPub::Publisher2);
}

::IceProxy::Ice::Object*
IceProxy::TestPub::Publisher2::__newInstance() const
{
    return new Publisher2;
}

const ::std::string&
IceProxy::TestPub::Subscriber1::ice_staticId()
{
    return ::TestPub::Subscriber1::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::TestPub::Subscriber1::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::TestPub::Subscriber1);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::TestPub::Subscriber1::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::TestPub::Subscriber1);
}

::IceProxy::Ice::Object*
IceProxy::TestPub::Subscriber1::__newInstance() const
{
    return new Subscriber1;
}

const ::std::string&
IceProxy::TestPub::Subscriber2::ice_staticId()
{
    return ::TestPub::Subscriber2::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::TestPub::Subscriber2::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::TestPub::Subscriber2);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::TestPub::Subscriber2::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::TestPub::Subscriber2);
}

::IceProxy::Ice::Object*
IceProxy::TestPub::Subscriber2::__newInstance() const
{
    return new Subscriber2;
}

void
IceDelegateM::EventsNS::Events::evolve(const ::EventsNS::EventPtr& e, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __EventsNS__Events__evolve_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(::Ice::ObjectPtr(::IceInternal::upCast(e.get())));
        __os->writePendingObjects();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    if(!__og.is()->b.empty())
    {
        try
        {
            if(!__ok)
            {
                try
                {
                    __og.throwUserException();
                }
                catch(const ::Ice::UserException& __ex)
                {
                    ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                    throw __uue;
                }
            }
            __og.is()->skipEmptyEncaps();
        }
        catch(const ::Ice::LocalException& __ex)
        {
            throw ::IceInternal::LocalExceptionWrapper(__ex, false);
        }
    }
}

void
IceDelegateD::EventsNS::Events::evolve(const ::EventsNS::EventPtr& e, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(const ::EventsNS::EventPtr& e, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _m_e(e)
        {
        }

        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::EventsNS::Events* servant = dynamic_cast< ::EventsNS::Events*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            servant->evolve(_m_e, _current);
            return ::Ice::DispatchOK;
        }

    private:

        const ::EventsNS::EventPtr& _m_e;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __EventsNS__Events__evolve_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(e, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
}

EventsNS::Event::Event(::Ice::Int __ice_id) :
    id(__ice_id)
{
}

::Ice::ObjectPtr
EventsNS::Event::ice_clone() const
{
    ::EventsNS::EventPtr __p = new ::EventsNS::Event(*this);
    return __p;
}

static const ::std::string __EventsNS__Event_ids[2] =
{
    "::EventsNS::Event",
    "::Ice::Object"
};

bool
EventsNS::Event::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__EventsNS__Event_ids, __EventsNS__Event_ids + 2, _s);
}

::std::vector< ::std::string>
EventsNS::Event::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__EventsNS__Event_ids[0], &__EventsNS__Event_ids[2]);
}

const ::std::string&
EventsNS::Event::ice_id(const ::Ice::Current&) const
{
    return __EventsNS__Event_ids[0];
}

const ::std::string&
EventsNS::Event::ice_staticId()
{
    return __EventsNS__Event_ids[0];
}

void
EventsNS::Event::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(id);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__write(__os);
#else
    ::Ice::Object::__write(__os);
#endif
}

void
EventsNS::Event::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(id);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__read(__is, true);
#else
    ::Ice::Object::__read(__is, true);
#endif
}

void
EventsNS::Event::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type EventsNS::Event was not generated with stream support";
    throw ex;
}

void
EventsNS::Event::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type EventsNS::Event was not generated with stream support";
    throw ex;
}

class __F__EventsNS__Event : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::EventsNS::Event::ice_staticId());
        return new ::EventsNS::Event;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__EventsNS__Event_Ptr = new __F__EventsNS__Event;

const ::Ice::ObjectFactoryPtr&
EventsNS::Event::ice_factory()
{
    return __F__EventsNS__Event_Ptr;
}

class __F__EventsNS__Event__Init
{
public:

    __F__EventsNS__Event__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::EventsNS::Event::ice_staticId(), ::EventsNS::Event::ice_factory());
    }

    ~__F__EventsNS__Event__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::EventsNS::Event::ice_staticId());
    }
};

static __F__EventsNS__Event__Init __F__EventsNS__Event__i;

#ifdef __APPLE__
extern "C" { void __F__EventsNS__Event__initializer() {} }
#endif

void
EventsNS::__patch__EventPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::EventsNS::EventPtr* p = static_cast< ::EventsNS::EventPtr*>(__addr);
    assert(p);
    *p = ::EventsNS::EventPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::EventsNS::Event::ice_staticId(), v->ice_id());
    }
}

bool
EventsNS::operator==(const ::EventsNS::Event& l, const ::EventsNS::Event& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
EventsNS::operator<(const ::EventsNS::Event& l, const ::EventsNS::Event& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

EventsNS::Message1::Message1(::Ice::Int __ice_id, ::Ice::Int __ice_m, const ::std::string& __ice_msg) :
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Event(__ice_id)
#else
    ::EventsNS::Event(__ice_id)
#endif
,
    m(__ice_m),
    msg(__ice_msg)
{
}

::Ice::ObjectPtr
EventsNS::Message1::ice_clone() const
{
    ::EventsNS::Message1Ptr __p = new ::EventsNS::Message1(*this);
    return __p;
}

static const ::std::string __EventsNS__Message1_ids[3] =
{
    "::EventsNS::Event",
    "::EventsNS::Message1",
    "::Ice::Object"
};

bool
EventsNS::Message1::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__EventsNS__Message1_ids, __EventsNS__Message1_ids + 3, _s);
}

::std::vector< ::std::string>
EventsNS::Message1::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__EventsNS__Message1_ids[0], &__EventsNS__Message1_ids[3]);
}

const ::std::string&
EventsNS::Message1::ice_id(const ::Ice::Current&) const
{
    return __EventsNS__Message1_ids[1];
}

const ::std::string&
EventsNS::Message1::ice_staticId()
{
    return __EventsNS__Message1_ids[1];
}

void
EventsNS::Message1::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(m);
    __os->write(msg);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Event::__write(__os);
#else
    ::EventsNS::Event::__write(__os);
#endif
}

void
EventsNS::Message1::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(m);
    __is->read(msg);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Event::__read(__is, true);
#else
    ::EventsNS::Event::__read(__is, true);
#endif
}

void
EventsNS::Message1::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type EventsNS::Message1 was not generated with stream support";
    throw ex;
}

void
EventsNS::Message1::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type EventsNS::Message1 was not generated with stream support";
    throw ex;
}

class __F__EventsNS__Message1 : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::EventsNS::Message1::ice_staticId());
        return new ::EventsNS::Message1;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__EventsNS__Message1_Ptr = new __F__EventsNS__Message1;

const ::Ice::ObjectFactoryPtr&
EventsNS::Message1::ice_factory()
{
    return __F__EventsNS__Message1_Ptr;
}

class __F__EventsNS__Message1__Init
{
public:

    __F__EventsNS__Message1__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::EventsNS::Message1::ice_staticId(), ::EventsNS::Message1::ice_factory());
    }

    ~__F__EventsNS__Message1__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::EventsNS::Message1::ice_staticId());
    }
};

static __F__EventsNS__Message1__Init __F__EventsNS__Message1__i;

#ifdef __APPLE__
extern "C" { void __F__EventsNS__Message1__initializer() {} }
#endif

void
EventsNS::__patch__Message1Ptr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::EventsNS::Message1Ptr* p = static_cast< ::EventsNS::Message1Ptr*>(__addr);
    assert(p);
    *p = ::EventsNS::Message1Ptr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::EventsNS::Message1::ice_staticId(), v->ice_id());
    }
}

bool
EventsNS::operator==(const ::EventsNS::Message1& l, const ::EventsNS::Message1& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
EventsNS::operator<(const ::EventsNS::Message1& l, const ::EventsNS::Message1& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

EventsNS::Message2::Message2(::Ice::Int __ice_id, ::Ice::Int __ice_i, ::Ice::Int __ice_j, const ::std::string& __ice_msg) :
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Event(__ice_id)
#else
    ::EventsNS::Event(__ice_id)
#endif
,
    i(__ice_i),
    j(__ice_j),
    msg(__ice_msg)
{
}

::Ice::ObjectPtr
EventsNS::Message2::ice_clone() const
{
    ::EventsNS::Message2Ptr __p = new ::EventsNS::Message2(*this);
    return __p;
}

static const ::std::string __EventsNS__Message2_ids[3] =
{
    "::EventsNS::Event",
    "::EventsNS::Message2",
    "::Ice::Object"
};

bool
EventsNS::Message2::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__EventsNS__Message2_ids, __EventsNS__Message2_ids + 3, _s);
}

::std::vector< ::std::string>
EventsNS::Message2::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__EventsNS__Message2_ids[0], &__EventsNS__Message2_ids[3]);
}

const ::std::string&
EventsNS::Message2::ice_id(const ::Ice::Current&) const
{
    return __EventsNS__Message2_ids[1];
}

const ::std::string&
EventsNS::Message2::ice_staticId()
{
    return __EventsNS__Message2_ids[1];
}

void
EventsNS::Message2::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(i);
    __os->write(j);
    __os->write(msg);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Event::__write(__os);
#else
    ::EventsNS::Event::__write(__os);
#endif
}

void
EventsNS::Message2::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(i);
    __is->read(j);
    __is->read(msg);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Event::__read(__is, true);
#else
    ::EventsNS::Event::__read(__is, true);
#endif
}

void
EventsNS::Message2::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type EventsNS::Message2 was not generated with stream support";
    throw ex;
}

void
EventsNS::Message2::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type EventsNS::Message2 was not generated with stream support";
    throw ex;
}

class __F__EventsNS__Message2 : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::EventsNS::Message2::ice_staticId());
        return new ::EventsNS::Message2;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__EventsNS__Message2_Ptr = new __F__EventsNS__Message2;

const ::Ice::ObjectFactoryPtr&
EventsNS::Message2::ice_factory()
{
    return __F__EventsNS__Message2_Ptr;
}

class __F__EventsNS__Message2__Init
{
public:

    __F__EventsNS__Message2__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::EventsNS::Message2::ice_staticId(), ::EventsNS::Message2::ice_factory());
    }

    ~__F__EventsNS__Message2__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::EventsNS::Message2::ice_staticId());
    }
};

static __F__EventsNS__Message2__Init __F__EventsNS__Message2__i;

#ifdef __APPLE__
extern "C" { void __F__EventsNS__Message2__initializer() {} }
#endif

void
EventsNS::__patch__Message2Ptr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::EventsNS::Message2Ptr* p = static_cast< ::EventsNS::Message2Ptr*>(__addr);
    assert(p);
    *p = ::EventsNS::Message2Ptr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::EventsNS::Message2::ice_staticId(), v->ice_id());
    }
}

bool
EventsNS::operator==(const ::EventsNS::Message2& l, const ::EventsNS::Message2& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
EventsNS::operator<(const ::EventsNS::Message2& l, const ::EventsNS::Message2& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

::Ice::ObjectPtr
EventsNS::Events::ice_clone() const
{
    throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
    return 0; // to avoid a warning with some compilers
}

static const ::std::string __EventsNS__Events_ids[2] =
{
    "::EventsNS::Events",
    "::Ice::Object"
};

bool
EventsNS::Events::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__EventsNS__Events_ids, __EventsNS__Events_ids + 2, _s);
}

::std::vector< ::std::string>
EventsNS::Events::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__EventsNS__Events_ids[0], &__EventsNS__Events_ids[2]);
}

const ::std::string&
EventsNS::Events::ice_id(const ::Ice::Current&) const
{
    return __EventsNS__Events_ids[0];
}

const ::std::string&
EventsNS::Events::ice_staticId()
{
    return __EventsNS__Events_ids[0];
}

::Ice::DispatchStatus
EventsNS::Events::___evolve(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::EventsNS::EventPtr e;
    __is->read(::EventsNS::__patch__EventPtr, &e);
    __is->readPendingObjects();
    __is->endReadEncaps();
    evolve(e, __current);
    return ::Ice::DispatchOK;
}

static ::std::string __EventsNS__Events_all[] =
{
    "evolve",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping"
};

::Ice::DispatchStatus
EventsNS::Events::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__EventsNS__Events_all, __EventsNS__Events_all + 5, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __EventsNS__Events_all)
    {
        case 0:
        {
            return ___evolve(in, current);
        }
        case 1:
        {
            return ___ice_id(in, current);
        }
        case 2:
        {
            return ___ice_ids(in, current);
        }
        case 3:
        {
            return ___ice_isA(in, current);
        }
        case 4:
        {
            return ___ice_ping(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

void
EventsNS::Events::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__write(__os);
#else
    ::Ice::Object::__write(__os);
#endif
}

void
EventsNS::Events::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__read(__is, true);
#else
    ::Ice::Object::__read(__is, true);
#endif
}

void
EventsNS::Events::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type EventsNS::Events was not generated with stream support";
    throw ex;
}

void
EventsNS::Events::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type EventsNS::Events was not generated with stream support";
    throw ex;
}

void
EventsNS::__patch__EventsPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::EventsNS::EventsPtr* p = static_cast< ::EventsNS::EventsPtr*>(__addr);
    assert(p);
    *p = ::EventsNS::EventsPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::EventsNS::Events::ice_staticId(), v->ice_id());
    }
}

bool
EventsNS::operator==(const ::EventsNS::Events& l, const ::EventsNS::Events& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
EventsNS::operator<(const ::EventsNS::Events& l, const ::EventsNS::Events& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

::Ice::ObjectPtr
TestPub::Publisher1::ice_clone() const
{
    throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
    return 0; // to avoid a warning with some compilers
}

static const ::std::string __TestPub__Publisher1_ids[3] =
{
    "::EventsNS::Events",
    "::Ice::Object",
    "::TestPub::Publisher1"
};

bool
TestPub::Publisher1::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__TestPub__Publisher1_ids, __TestPub__Publisher1_ids + 3, _s);
}

::std::vector< ::std::string>
TestPub::Publisher1::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__TestPub__Publisher1_ids[0], &__TestPub__Publisher1_ids[3]);
}

const ::std::string&
TestPub::Publisher1::ice_id(const ::Ice::Current&) const
{
    return __TestPub__Publisher1_ids[2];
}

const ::std::string&
TestPub::Publisher1::ice_staticId()
{
    return __TestPub__Publisher1_ids[2];
}

static ::std::string __TestPub__Publisher1_all[] =
{
    "evolve",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping"
};

::Ice::DispatchStatus
TestPub::Publisher1::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__TestPub__Publisher1_all, __TestPub__Publisher1_all + 5, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __TestPub__Publisher1_all)
    {
        case 0:
        {
            return ___evolve(in, current);
        }
        case 1:
        {
            return ___ice_id(in, current);
        }
        case 2:
        {
            return ___ice_ids(in, current);
        }
        case 3:
        {
            return ___ice_isA(in, current);
        }
        case 4:
        {
            return ___ice_ping(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

void
TestPub::Publisher1::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__write(__os);
#else
    ::Ice::Object::__write(__os);
#endif
}

void
TestPub::Publisher1::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__read(__is, true);
#else
    ::Ice::Object::__read(__is, true);
#endif
}

void
TestPub::Publisher1::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type TestPub::Publisher1 was not generated with stream support";
    throw ex;
}

void
TestPub::Publisher1::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type TestPub::Publisher1 was not generated with stream support";
    throw ex;
}

void
TestPub::__patch__Publisher1Ptr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::TestPub::Publisher1Ptr* p = static_cast< ::TestPub::Publisher1Ptr*>(__addr);
    assert(p);
    *p = ::TestPub::Publisher1Ptr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::TestPub::Publisher1::ice_staticId(), v->ice_id());
    }
}

bool
TestPub::operator==(const ::TestPub::Publisher1& l, const ::TestPub::Publisher1& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
TestPub::operator<(const ::TestPub::Publisher1& l, const ::TestPub::Publisher1& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

::Ice::ObjectPtr
TestPub::Publisher2::ice_clone() const
{
    throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
    return 0; // to avoid a warning with some compilers
}

static const ::std::string __TestPub__Publisher2_ids[3] =
{
    "::EventsNS::Events",
    "::Ice::Object",
    "::TestPub::Publisher2"
};

bool
TestPub::Publisher2::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__TestPub__Publisher2_ids, __TestPub__Publisher2_ids + 3, _s);
}

::std::vector< ::std::string>
TestPub::Publisher2::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__TestPub__Publisher2_ids[0], &__TestPub__Publisher2_ids[3]);
}

const ::std::string&
TestPub::Publisher2::ice_id(const ::Ice::Current&) const
{
    return __TestPub__Publisher2_ids[2];
}

const ::std::string&
TestPub::Publisher2::ice_staticId()
{
    return __TestPub__Publisher2_ids[2];
}

static ::std::string __TestPub__Publisher2_all[] =
{
    "evolve",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping"
};

::Ice::DispatchStatus
TestPub::Publisher2::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__TestPub__Publisher2_all, __TestPub__Publisher2_all + 5, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __TestPub__Publisher2_all)
    {
        case 0:
        {
            return ___evolve(in, current);
        }
        case 1:
        {
            return ___ice_id(in, current);
        }
        case 2:
        {
            return ___ice_ids(in, current);
        }
        case 3:
        {
            return ___ice_isA(in, current);
        }
        case 4:
        {
            return ___ice_ping(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

void
TestPub::Publisher2::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__write(__os);
#else
    ::Ice::Object::__write(__os);
#endif
}

void
TestPub::Publisher2::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__read(__is, true);
#else
    ::Ice::Object::__read(__is, true);
#endif
}

void
TestPub::Publisher2::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type TestPub::Publisher2 was not generated with stream support";
    throw ex;
}

void
TestPub::Publisher2::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type TestPub::Publisher2 was not generated with stream support";
    throw ex;
}

void
TestPub::__patch__Publisher2Ptr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::TestPub::Publisher2Ptr* p = static_cast< ::TestPub::Publisher2Ptr*>(__addr);
    assert(p);
    *p = ::TestPub::Publisher2Ptr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::TestPub::Publisher2::ice_staticId(), v->ice_id());
    }
}

bool
TestPub::operator==(const ::TestPub::Publisher2& l, const ::TestPub::Publisher2& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
TestPub::operator<(const ::TestPub::Publisher2& l, const ::TestPub::Publisher2& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

::Ice::ObjectPtr
TestPub::Subscriber1::ice_clone() const
{
    throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
    return 0; // to avoid a warning with some compilers
}

static const ::std::string __TestPub__Subscriber1_ids[3] =
{
    "::EventsNS::Events",
    "::Ice::Object",
    "::TestPub::Subscriber1"
};

bool
TestPub::Subscriber1::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__TestPub__Subscriber1_ids, __TestPub__Subscriber1_ids + 3, _s);
}

::std::vector< ::std::string>
TestPub::Subscriber1::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__TestPub__Subscriber1_ids[0], &__TestPub__Subscriber1_ids[3]);
}

const ::std::string&
TestPub::Subscriber1::ice_id(const ::Ice::Current&) const
{
    return __TestPub__Subscriber1_ids[2];
}

const ::std::string&
TestPub::Subscriber1::ice_staticId()
{
    return __TestPub__Subscriber1_ids[2];
}

static ::std::string __TestPub__Subscriber1_all[] =
{
    "evolve",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping"
};

::Ice::DispatchStatus
TestPub::Subscriber1::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__TestPub__Subscriber1_all, __TestPub__Subscriber1_all + 5, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __TestPub__Subscriber1_all)
    {
        case 0:
        {
            return ___evolve(in, current);
        }
        case 1:
        {
            return ___ice_id(in, current);
        }
        case 2:
        {
            return ___ice_ids(in, current);
        }
        case 3:
        {
            return ___ice_isA(in, current);
        }
        case 4:
        {
            return ___ice_ping(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

void
TestPub::Subscriber1::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__write(__os);
#else
    ::Ice::Object::__write(__os);
#endif
}

void
TestPub::Subscriber1::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__read(__is, true);
#else
    ::Ice::Object::__read(__is, true);
#endif
}

void
TestPub::Subscriber1::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type TestPub::Subscriber1 was not generated with stream support";
    throw ex;
}

void
TestPub::Subscriber1::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type TestPub::Subscriber1 was not generated with stream support";
    throw ex;
}

void
TestPub::__patch__Subscriber1Ptr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::TestPub::Subscriber1Ptr* p = static_cast< ::TestPub::Subscriber1Ptr*>(__addr);
    assert(p);
    *p = ::TestPub::Subscriber1Ptr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::TestPub::Subscriber1::ice_staticId(), v->ice_id());
    }
}

bool
TestPub::operator==(const ::TestPub::Subscriber1& l, const ::TestPub::Subscriber1& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
TestPub::operator<(const ::TestPub::Subscriber1& l, const ::TestPub::Subscriber1& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

::Ice::ObjectPtr
TestPub::Subscriber2::ice_clone() const
{
    throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
    return 0; // to avoid a warning with some compilers
}

static const ::std::string __TestPub__Subscriber2_ids[3] =
{
    "::EventsNS::Events",
    "::Ice::Object",
    "::TestPub::Subscriber2"
};

bool
TestPub::Subscriber2::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__TestPub__Subscriber2_ids, __TestPub__Subscriber2_ids + 3, _s);
}

::std::vector< ::std::string>
TestPub::Subscriber2::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__TestPub__Subscriber2_ids[0], &__TestPub__Subscriber2_ids[3]);
}

const ::std::string&
TestPub::Subscriber2::ice_id(const ::Ice::Current&) const
{
    return __TestPub__Subscriber2_ids[2];
}

const ::std::string&
TestPub::Subscriber2::ice_staticId()
{
    return __TestPub__Subscriber2_ids[2];
}

static ::std::string __TestPub__Subscriber2_all[] =
{
    "evolve",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping"
};

::Ice::DispatchStatus
TestPub::Subscriber2::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__TestPub__Subscriber2_all, __TestPub__Subscriber2_all + 5, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __TestPub__Subscriber2_all)
    {
        case 0:
        {
            return ___evolve(in, current);
        }
        case 1:
        {
            return ___ice_id(in, current);
        }
        case 2:
        {
            return ___ice_ids(in, current);
        }
        case 3:
        {
            return ___ice_isA(in, current);
        }
        case 4:
        {
            return ___ice_ping(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

void
TestPub::Subscriber2::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__write(__os);
#else
    ::Ice::Object::__write(__os);
#endif
}

void
TestPub::Subscriber2::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__read(__is, true);
#else
    ::Ice::Object::__read(__is, true);
#endif
}

void
TestPub::Subscriber2::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type TestPub::Subscriber2 was not generated with stream support";
    throw ex;
}

void
TestPub::Subscriber2::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type TestPub::Subscriber2 was not generated with stream support";
    throw ex;
}

void
TestPub::__patch__Subscriber2Ptr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::TestPub::Subscriber2Ptr* p = static_cast< ::TestPub::Subscriber2Ptr*>(__addr);
    assert(p);
    *p = ::TestPub::Subscriber2Ptr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::TestPub::Subscriber2::ice_staticId(), v->ice_id());
    }
}

bool
TestPub::operator==(const ::TestPub::Subscriber2& l, const ::TestPub::Subscriber2& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
TestPub::operator<(const ::TestPub::Subscriber2& l, const ::TestPub::Subscriber2& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}