ChipInfoIce.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 `ChipInfoIce.ice'

#include <ChipInfoIce.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 __ChipInfoIceMod__ChipInfoServerIce__update_name = "update";

static const ::std::string __ChipInfoIceMod__ChipInfoServerIce__getSmap_name = "getSmap";

static const ::std::string __ChipInfoIceMod__ChipInfoServerIce__getBelief_name = "getBelief";

static const ::std::string __ChipInfoIceMod__ChipInfoServerIce__getBelief2_name = "getBelief2";

static const ::std::string __ChipInfoIceMod__ChipInfoServerIce__getHist_name = "getHist";

static const ::std::string __ChipInfoIceMod__ChipInfoServerIce__registerChips_name = "registerChips";

static const ::std::string __ChipInfoIceMod__ChipInfoServerIce__startServer_name = "startServer";

static const ::std::string __ChipInfoIceMod__ChipInfoServerIce__getAvgChipsSec_name = "getAvgChipsSec";

static const ::std::string __ChipInfoIceMod__ChipInfoServerFactoryIce__createServer_name = "createServer";

::Ice::Object* IceInternal::upCast(::ChipInfoIceMod::ChipInfoServerIce* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::ChipInfoIceMod::ChipInfoServerIce* p) { return p; }

::Ice::Object* IceInternal::upCast(::ChipInfoIceMod::ChipInfoServerFactoryIce* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::ChipInfoIceMod::ChipInfoServerFactoryIce* p) { return p; }

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

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

bool
ChipInfoIceMod::AMI_ChipInfoServerIce_update::__invoke(const ::ChipInfoIceMod::ChipInfoServerIcePrx& __prx, const ::ImageIceMod::ImageIce& image, ::Ice::Int chipID, const ::Ice::Context* __ctx)
{
    __acquireCallback(__prx);
    try
    {
        __prx->__checkTwowayOnly(__ChipInfoIceMod__ChipInfoServerIce__update_name);
        __prepare(__prx, __ChipInfoIceMod__ChipInfoServerIce__update_name, ::Ice::Normal, __ctx);
        image.__write(__os);
        __os->write(chipID);
        __os->endWriteEncaps();
        return __send();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __releaseCallback(__ex);
        return false;
    }
}

void
ChipInfoIceMod::AMI_ChipInfoServerIce_update::__response(bool __ok)
{
    ::Ice::Double __ret;
    try
    {
        if(!__ok)
        {
            try
            {
                __throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
            }
            return;
        }
        __is->startReadEncaps();
        __is->read(__ret);
        __is->endReadEncaps();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __finished(__ex);
        return;
    }
    ice_response(__ret);
    __releaseCallback();
}

::Ice::Double
IceProxy::ChipInfoIceMod::ChipInfoServerIce::update(const ::ImageIceMod::ImageIce& image, ::Ice::Int chipID, 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
            __checkTwowayOnly(__ChipInfoIceMod__ChipInfoServerIce__update_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::ChipInfoIceMod::ChipInfoServerIce* __del = dynamic_cast< ::IceDelegate::ChipInfoIceMod::ChipInfoServerIce*>(__delBase.get());
            return __del->update(image, chipID, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

bool
IceProxy::ChipInfoIceMod::ChipInfoServerIce::update_async(const ::ChipInfoIceMod::AMI_ChipInfoServerIce_updatePtr& __cb, const ::ImageIceMod::ImageIce& image, ::Ice::Int chipID)
{
    return __cb->__invoke(this, image, chipID, 0);
}

bool
IceProxy::ChipInfoIceMod::ChipInfoServerIce::update_async(const ::ChipInfoIceMod::AMI_ChipInfoServerIce_updatePtr& __cb, const ::ImageIceMod::ImageIce& image, ::Ice::Int chipID, const ::Ice::Context& __ctx)
{
    return __cb->__invoke(this, image, chipID, &__ctx);
}

::ImageIceMod::ImageIce
IceProxy::ChipInfoIceMod::ChipInfoServerIce::getSmap(::Ice::Int chipID, 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
            __checkTwowayOnly(__ChipInfoIceMod__ChipInfoServerIce__getSmap_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::ChipInfoIceMod::ChipInfoServerIce* __del = dynamic_cast< ::IceDelegate::ChipInfoIceMod::ChipInfoServerIce*>(__delBase.get());
            return __del->getSmap(chipID, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::ChipInfoIceMod::DoubleSeq
IceProxy::ChipInfoIceMod::ChipInfoServerIce::getBelief(::Ice::Int chipID, 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
            __checkTwowayOnly(__ChipInfoIceMod__ChipInfoServerIce__getBelief_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::ChipInfoIceMod::ChipInfoServerIce* __del = dynamic_cast< ::IceDelegate::ChipInfoIceMod::ChipInfoServerIce*>(__delBase.get());
            return __del->getBelief(chipID, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::ChipInfoIceMod::DoubleSeq
IceProxy::ChipInfoIceMod::ChipInfoServerIce::getBelief2(::Ice::Int chipID, 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
            __checkTwowayOnly(__ChipInfoIceMod__ChipInfoServerIce__getBelief2_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::ChipInfoIceMod::ChipInfoServerIce* __del = dynamic_cast< ::IceDelegate::ChipInfoIceMod::ChipInfoServerIce*>(__delBase.get());
            return __del->getBelief2(chipID, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::ChipInfoIceMod::DoubleSeq
IceProxy::ChipInfoIceMod::ChipInfoServerIce::getHist(::Ice::Int chipID, 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
            __checkTwowayOnly(__ChipInfoIceMod__ChipInfoServerIce__getHist_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::ChipInfoIceMod::ChipInfoServerIce* __del = dynamic_cast< ::IceDelegate::ChipInfoIceMod::ChipInfoServerIce*>(__delBase.get());
            return __del->getHist(chipID, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::ChipInfoIceMod::ChipInfoServerIce::registerChips(const ::ChipInfoIceMod::IntSeq& chipIDList, 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::ChipInfoIceMod::ChipInfoServerIce* __del = dynamic_cast< ::IceDelegate::ChipInfoIceMod::ChipInfoServerIce*>(__delBase.get());
            __del->registerChips(chipIDList, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::ChipInfoIceMod::ChipInfoServerIce::startServer(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::ChipInfoIceMod::ChipInfoServerIce* __del = dynamic_cast< ::IceDelegate::ChipInfoIceMod::ChipInfoServerIce*>(__delBase.get());
            __del->startServer(__ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::Ice::Float
IceProxy::ChipInfoIceMod::ChipInfoServerIce::getAvgChipsSec(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
            __checkTwowayOnly(__ChipInfoIceMod__ChipInfoServerIce__getAvgChipsSec_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::ChipInfoIceMod::ChipInfoServerIce* __del = dynamic_cast< ::IceDelegate::ChipInfoIceMod::ChipInfoServerIce*>(__delBase.get());
            return __del->getAvgChipsSec(__ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

const ::std::string&
IceProxy::ChipInfoIceMod::ChipInfoServerIce::ice_staticId()
{
    return ::ChipInfoIceMod::ChipInfoServerIce::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::ChipInfoIceMod::ChipInfoServerIce::__newInstance() const
{
    return new ChipInfoServerIce;
}

::ChipInfoIceMod::ChipInfoServerIcePrx
IceProxy::ChipInfoIceMod::ChipInfoServerFactoryIce::createServer(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
            __checkTwowayOnly(__ChipInfoIceMod__ChipInfoServerFactoryIce__createServer_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::ChipInfoIceMod::ChipInfoServerFactoryIce* __del = dynamic_cast< ::IceDelegate::ChipInfoIceMod::ChipInfoServerFactoryIce*>(__delBase.get());
            return __del->createServer(__ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

const ::std::string&
IceProxy::ChipInfoIceMod::ChipInfoServerFactoryIce::ice_staticId()
{
    return ::ChipInfoIceMod::ChipInfoServerFactoryIce::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::ChipInfoIceMod::ChipInfoServerFactoryIce::__newInstance() const
{
    return new ChipInfoServerFactoryIce;
}

::Ice::Double
IceDelegateM::ChipInfoIceMod::ChipInfoServerIce::update(const ::ImageIceMod::ImageIce& image, ::Ice::Int chipID, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __ChipInfoIceMod__ChipInfoServerIce__update_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        image.__write(__os);
        __os->write(chipID);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    ::Ice::Double __ret;
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->read(__ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::ImageIceMod::ImageIce
IceDelegateM::ChipInfoIceMod::ChipInfoServerIce::getSmap(::Ice::Int chipID, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __ChipInfoIceMod__ChipInfoServerIce__getSmap_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(chipID);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    ::ImageIceMod::ImageIce __ret;
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __ret.__read(__is);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::ChipInfoIceMod::DoubleSeq
IceDelegateM::ChipInfoIceMod::ChipInfoServerIce::getBelief(::Ice::Int chipID, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __ChipInfoIceMod__ChipInfoServerIce__getBelief_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(chipID);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    ::ChipInfoIceMod::DoubleSeq __ret;
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->read(__ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::ChipInfoIceMod::DoubleSeq
IceDelegateM::ChipInfoIceMod::ChipInfoServerIce::getBelief2(::Ice::Int chipID, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __ChipInfoIceMod__ChipInfoServerIce__getBelief2_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(chipID);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    ::ChipInfoIceMod::DoubleSeq __ret;
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->read(__ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::ChipInfoIceMod::DoubleSeq
IceDelegateM::ChipInfoIceMod::ChipInfoServerIce::getHist(::Ice::Int chipID, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __ChipInfoIceMod__ChipInfoServerIce__getHist_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(chipID);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    ::ChipInfoIceMod::DoubleSeq __ret;
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->read(__ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

void
IceDelegateM::ChipInfoIceMod::ChipInfoServerIce::registerChips(const ::ChipInfoIceMod::IntSeq& chipIDList, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __ChipInfoIceMod__ChipInfoServerIce__registerChips_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        if(chipIDList.size() == 0)
        {
            __os->writeSize(0);
        }
        else
        {
            __os->write(&chipIDList[0], &chipIDList[0] + chipIDList.size());
        }
    }
    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
IceDelegateM::ChipInfoIceMod::ChipInfoServerIce::startServer(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __ChipInfoIceMod__ChipInfoServerIce__startServer_name, ::Ice::Normal, __context);
    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);
        }
    }
}

::Ice::Float
IceDelegateM::ChipInfoIceMod::ChipInfoServerIce::getAvgChipsSec(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __ChipInfoIceMod__ChipInfoServerIce__getAvgChipsSec_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    ::Ice::Float __ret;
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->read(__ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::ChipInfoIceMod::ChipInfoServerIcePrx
IceDelegateM::ChipInfoIceMod::ChipInfoServerFactoryIce::createServer(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __ChipInfoIceMod__ChipInfoServerFactoryIce__createServer_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    ::ChipInfoIceMod::ChipInfoServerIcePrx __ret;
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        ::ChipInfoIceMod::__read(__is, __ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::Ice::Double
IceDelegateD::ChipInfoIceMod::ChipInfoServerIce::update(const ::ImageIceMod::ImageIce& image, ::Ice::Int chipID, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Double& __result, const ::ImageIceMod::ImageIce& image, ::Ice::Int chipID, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_image(image),
            _m_chipID(chipID)
        {
        }

        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::ChipInfoIceMod::ChipInfoServerIce* servant = dynamic_cast< ::ChipInfoIceMod::ChipInfoServerIce*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            _result = servant->update(_m_image, _m_chipID, _current);
            return ::Ice::DispatchOK;
        }

    private:

        ::Ice::Double& _result;
        const ::ImageIceMod::ImageIce& _m_image;
        ::Ice::Int _m_chipID;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __ChipInfoIceMod__ChipInfoServerIce__update_name, ::Ice::Normal, __context);
    ::Ice::Double __result;
    try
    {
        _DirectI __direct(__result, image, chipID, __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);
    }
    return __result;
}

::ImageIceMod::ImageIce
IceDelegateD::ChipInfoIceMod::ChipInfoServerIce::getSmap(::Ice::Int chipID, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::ImageIceMod::ImageIce& __result, ::Ice::Int chipID, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_chipID(chipID)
        {
        }

        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::ChipInfoIceMod::ChipInfoServerIce* servant = dynamic_cast< ::ChipInfoIceMod::ChipInfoServerIce*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            _result = servant->getSmap(_m_chipID, _current);
            return ::Ice::DispatchOK;
        }

    private:

        ::ImageIceMod::ImageIce& _result;
        ::Ice::Int _m_chipID;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __ChipInfoIceMod__ChipInfoServerIce__getSmap_name, ::Ice::Normal, __context);
    ::ImageIceMod::ImageIce __result;
    try
    {
        _DirectI __direct(__result, chipID, __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);
    }
    return __result;
}

::ChipInfoIceMod::DoubleSeq
IceDelegateD::ChipInfoIceMod::ChipInfoServerIce::getBelief(::Ice::Int chipID, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::ChipInfoIceMod::DoubleSeq& __result, ::Ice::Int chipID, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_chipID(chipID)
        {
        }

        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::ChipInfoIceMod::ChipInfoServerIce* servant = dynamic_cast< ::ChipInfoIceMod::ChipInfoServerIce*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            _result = servant->getBelief(_m_chipID, _current);
            return ::Ice::DispatchOK;
        }

    private:

        ::ChipInfoIceMod::DoubleSeq& _result;
        ::Ice::Int _m_chipID;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __ChipInfoIceMod__ChipInfoServerIce__getBelief_name, ::Ice::Normal, __context);
    ::ChipInfoIceMod::DoubleSeq __result;
    try
    {
        _DirectI __direct(__result, chipID, __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);
    }
    return __result;
}

::ChipInfoIceMod::DoubleSeq
IceDelegateD::ChipInfoIceMod::ChipInfoServerIce::getBelief2(::Ice::Int chipID, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::ChipInfoIceMod::DoubleSeq& __result, ::Ice::Int chipID, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_chipID(chipID)
        {
        }

        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::ChipInfoIceMod::ChipInfoServerIce* servant = dynamic_cast< ::ChipInfoIceMod::ChipInfoServerIce*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            _result = servant->getBelief2(_m_chipID, _current);
            return ::Ice::DispatchOK;
        }

    private:

        ::ChipInfoIceMod::DoubleSeq& _result;
        ::Ice::Int _m_chipID;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __ChipInfoIceMod__ChipInfoServerIce__getBelief2_name, ::Ice::Normal, __context);
    ::ChipInfoIceMod::DoubleSeq __result;
    try
    {
        _DirectI __direct(__result, chipID, __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);
    }
    return __result;
}

::ChipInfoIceMod::DoubleSeq
IceDelegateD::ChipInfoIceMod::ChipInfoServerIce::getHist(::Ice::Int chipID, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::ChipInfoIceMod::DoubleSeq& __result, ::Ice::Int chipID, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_chipID(chipID)
        {
        }

        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::ChipInfoIceMod::ChipInfoServerIce* servant = dynamic_cast< ::ChipInfoIceMod::ChipInfoServerIce*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            _result = servant->getHist(_m_chipID, _current);
            return ::Ice::DispatchOK;
        }

    private:

        ::ChipInfoIceMod::DoubleSeq& _result;
        ::Ice::Int _m_chipID;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __ChipInfoIceMod__ChipInfoServerIce__getHist_name, ::Ice::Normal, __context);
    ::ChipInfoIceMod::DoubleSeq __result;
    try
    {
        _DirectI __direct(__result, chipID, __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);
    }
    return __result;
}

void
IceDelegateD::ChipInfoIceMod::ChipInfoServerIce::registerChips(const ::ChipInfoIceMod::IntSeq& chipIDList, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(const ::ChipInfoIceMod::IntSeq& chipIDList, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _m_chipIDList(chipIDList)
        {
        }

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

    private:

        const ::ChipInfoIceMod::IntSeq& _m_chipIDList;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __ChipInfoIceMod__ChipInfoServerIce__registerChips_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(chipIDList, __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);
    }
}

void
IceDelegateD::ChipInfoIceMod::ChipInfoServerIce::startServer(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current)
        {
        }

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

    private:

    };

    ::Ice::Current __current;
    __initCurrent(__current, __ChipInfoIceMod__ChipInfoServerIce__startServer_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(__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);
    }
}

::Ice::Float
IceDelegateD::ChipInfoIceMod::ChipInfoServerIce::getAvgChipsSec(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Float& __result, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result)
        {
        }

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

    private:

        ::Ice::Float& _result;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __ChipInfoIceMod__ChipInfoServerIce__getAvgChipsSec_name, ::Ice::Normal, __context);
    ::Ice::Float __result;
    try
    {
        _DirectI __direct(__result, __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);
    }
    return __result;
}

::ChipInfoIceMod::ChipInfoServerIcePrx
IceDelegateD::ChipInfoIceMod::ChipInfoServerFactoryIce::createServer(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::ChipInfoIceMod::ChipInfoServerIcePrx& __result, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result)
        {
        }

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

    private:

        ::ChipInfoIceMod::ChipInfoServerIcePrx& _result;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __ChipInfoIceMod__ChipInfoServerFactoryIce__createServer_name, ::Ice::Normal, __context);
    ::ChipInfoIceMod::ChipInfoServerIcePrx __result;
    try
    {
        _DirectI __direct(__result, __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);
    }
    return __result;
}

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

static const ::std::string __ChipInfoIceMod__ChipInfoServerIce_ids[2] =
{
    "::ChipInfoIceMod::ChipInfoServerIce",
    "::Ice::Object"
};

bool
ChipInfoIceMod::ChipInfoServerIce::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__ChipInfoIceMod__ChipInfoServerIce_ids, __ChipInfoIceMod__ChipInfoServerIce_ids + 2, _s);
}

::std::vector< ::std::string>
ChipInfoIceMod::ChipInfoServerIce::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__ChipInfoIceMod__ChipInfoServerIce_ids[0], &__ChipInfoIceMod__ChipInfoServerIce_ids[2]);
}

const ::std::string&
ChipInfoIceMod::ChipInfoServerIce::ice_id(const ::Ice::Current&) const
{
    return __ChipInfoIceMod__ChipInfoServerIce_ids[0];
}

const ::std::string&
ChipInfoIceMod::ChipInfoServerIce::ice_staticId()
{
    return __ChipInfoIceMod__ChipInfoServerIce_ids[0];
}

::Ice::DispatchStatus
ChipInfoIceMod::ChipInfoServerIce::___update(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::ImageIceMod::ImageIce image;
    ::Ice::Int chipID;
    image.__read(__is);
    __is->read(chipID);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Ice::Double __ret = update(image, chipID, __current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
ChipInfoIceMod::ChipInfoServerIce::___getSmap(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Int chipID;
    __is->read(chipID);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::ImageIceMod::ImageIce __ret = getSmap(chipID, __current);
    __ret.__write(__os);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
ChipInfoIceMod::ChipInfoServerIce::___getBelief(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Int chipID;
    __is->read(chipID);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::ChipInfoIceMod::DoubleSeq __ret = getBelief(chipID, __current);
    if(__ret.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        __os->write(&__ret[0], &__ret[0] + __ret.size());
    }
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
ChipInfoIceMod::ChipInfoServerIce::___getBelief2(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Int chipID;
    __is->read(chipID);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::ChipInfoIceMod::DoubleSeq __ret = getBelief2(chipID, __current);
    if(__ret.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        __os->write(&__ret[0], &__ret[0] + __ret.size());
    }
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
ChipInfoIceMod::ChipInfoServerIce::___getHist(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Int chipID;
    __is->read(chipID);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::ChipInfoIceMod::DoubleSeq __ret = getHist(chipID, __current);
    if(__ret.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        __os->write(&__ret[0], &__ret[0] + __ret.size());
    }
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
ChipInfoIceMod::ChipInfoServerIce::___registerChips(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::ChipInfoIceMod::IntSeq chipIDList;
    __is->read(chipIDList);
    __is->endReadEncaps();
    registerChips(chipIDList, __current);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
ChipInfoIceMod::ChipInfoServerIce::___startServer(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    startServer(__current);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
ChipInfoIceMod::ChipInfoServerIce::___getAvgChipsSec(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Ice::Float __ret = getAvgChipsSec(__current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

static ::std::string __ChipInfoIceMod__ChipInfoServerIce_all[] =
{
    "getAvgChipsSec",
    "getBelief",
    "getBelief2",
    "getHist",
    "getSmap",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping",
    "registerChips",
    "startServer",
    "update"
};

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

    switch(r.first - __ChipInfoIceMod__ChipInfoServerIce_all)
    {
        case 0:
        {
            return ___getAvgChipsSec(in, current);
        }
        case 1:
        {
            return ___getBelief(in, current);
        }
        case 2:
        {
            return ___getBelief2(in, current);
        }
        case 3:
        {
            return ___getHist(in, current);
        }
        case 4:
        {
            return ___getSmap(in, current);
        }
        case 5:
        {
            return ___ice_id(in, current);
        }
        case 6:
        {
            return ___ice_ids(in, current);
        }
        case 7:
        {
            return ___ice_isA(in, current);
        }
        case 8:
        {
            return ___ice_ping(in, current);
        }
        case 9:
        {
            return ___registerChips(in, current);
        }
        case 10:
        {
            return ___startServer(in, current);
        }
        case 11:
        {
            return ___update(in, current);
        }
    }

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

void
ChipInfoIceMod::ChipInfoServerIce::__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
ChipInfoIceMod::ChipInfoServerIce::__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
ChipInfoIceMod::ChipInfoServerIce::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type ChipInfoIceMod::ChipInfoServerIce was not generated with stream support";
    throw ex;
}

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

void
ChipInfoIceMod::__patch__ChipInfoServerIcePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::ChipInfoIceMod::ChipInfoServerIcePtr* p = static_cast< ::ChipInfoIceMod::ChipInfoServerIcePtr*>(__addr);
    assert(p);
    *p = ::ChipInfoIceMod::ChipInfoServerIcePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::ChipInfoIceMod::ChipInfoServerIce::ice_staticId(), v->ice_id());
    }
}

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

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

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

static const ::std::string __ChipInfoIceMod__ChipInfoServerFactoryIce_ids[2] =
{
    "::ChipInfoIceMod::ChipInfoServerFactoryIce",
    "::Ice::Object"
};

bool
ChipInfoIceMod::ChipInfoServerFactoryIce::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__ChipInfoIceMod__ChipInfoServerFactoryIce_ids, __ChipInfoIceMod__ChipInfoServerFactoryIce_ids + 2, _s);
}

::std::vector< ::std::string>
ChipInfoIceMod::ChipInfoServerFactoryIce::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__ChipInfoIceMod__ChipInfoServerFactoryIce_ids[0], &__ChipInfoIceMod__ChipInfoServerFactoryIce_ids[2]);
}

const ::std::string&
ChipInfoIceMod::ChipInfoServerFactoryIce::ice_id(const ::Ice::Current&) const
{
    return __ChipInfoIceMod__ChipInfoServerFactoryIce_ids[0];
}

const ::std::string&
ChipInfoIceMod::ChipInfoServerFactoryIce::ice_staticId()
{
    return __ChipInfoIceMod__ChipInfoServerFactoryIce_ids[0];
}

::Ice::DispatchStatus
ChipInfoIceMod::ChipInfoServerFactoryIce::___createServer(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::ChipInfoIceMod::ChipInfoServerIcePrx __ret = createServer(__current);
    __os->write(::Ice::ObjectPrx(::IceInternal::upCast(__ret.get())));
    return ::Ice::DispatchOK;
}

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

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

    switch(r.first - __ChipInfoIceMod__ChipInfoServerFactoryIce_all)
    {
        case 0:
        {
            return ___createServer(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
ChipInfoIceMod::ChipInfoServerFactoryIce::__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
ChipInfoIceMod::ChipInfoServerFactoryIce::__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
ChipInfoIceMod::ChipInfoServerFactoryIce::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type ChipInfoIceMod::ChipInfoServerFactoryIce was not generated with stream support";
    throw ex;
}

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

void
ChipInfoIceMod::__patch__ChipInfoServerFactoryIcePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::ChipInfoIceMod::ChipInfoServerFactoryIcePtr* p = static_cast< ::ChipInfoIceMod::ChipInfoServerFactoryIcePtr*>(__addr);
    assert(p);
    *p = ::ChipInfoIceMod::ChipInfoServerFactoryIcePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::ChipInfoIceMod::ChipInfoServerFactoryIce::ice_staticId(), v->ice_id());
    }
}

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

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