//
// Copyright (c) ZeroC, Inc. All rights reserved.
//
//
// Ice version 3.7.6
//
// <auto-generated>
//
// Generated from file `Metrics.ice'
//
// Warning: do not edit this file.
//
// </auto-generated>
//

#ifndef ICE_API_EXPORTS
#   define ICE_API_EXPORTS
#endif
#include <Ice/Metrics.h>
#include <IceUtil/PushDisableWarnings.h>
#include <Ice/LocalException.h>
#include <Ice/ValueFactory.h>
#include <Ice/OutgoingAsync.h>
#include <Ice/InputStream.h>
#include <Ice/OutputStream.h>
#include <Ice/LocalException.h>
#include <IceUtil/PopDisableWarnings.h>

#if defined(_MSC_VER)
#   pragma warning(disable:4458) // declaration of ... hides class member
#elif defined(__clang__)
#   pragma clang diagnostic ignored "-Wshadow"
#elif defined(__GNUC__)
#   pragma GCC diagnostic ignored "-Wshadow"
#endif

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

#ifdef ICE_CPP11_MAPPING // C++11 mapping

namespace
{

const ::IceInternal::DefaultValueFactoryInit<::IceMX::Metrics> iceC_IceMX_Metrics_init("::IceMX::Metrics");

const ::IceInternal::DefaultUserExceptionFactoryInit<::IceMX::UnknownMetricsView> iceC_IceMX_UnknownMetricsView_init("::IceMX::UnknownMetricsView");

const ::std::string iceC_IceMX_MetricsAdmin_ids[2] =
{
    "::Ice::Object",
    "::IceMX::MetricsAdmin"
};
const ::std::string iceC_IceMX_MetricsAdmin_ops[] =
{
    "disableMetricsView",
    "enableMetricsView",
    "getMapMetricsFailures",
    "getMetricsFailures",
    "getMetricsView",
    "getMetricsViewNames",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping"
};
const ::std::string iceC_IceMX_MetricsAdmin_getMetricsViewNames_name = "getMetricsViewNames";
const ::std::string iceC_IceMX_MetricsAdmin_enableMetricsView_name = "enableMetricsView";
const ::std::string iceC_IceMX_MetricsAdmin_disableMetricsView_name = "disableMetricsView";
const ::std::string iceC_IceMX_MetricsAdmin_getMetricsView_name = "getMetricsView";
const ::std::string iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name = "getMapMetricsFailures";
const ::std::string iceC_IceMX_MetricsAdmin_getMetricsFailures_name = "getMetricsFailures";

const ::IceInternal::DefaultValueFactoryInit<::IceMX::ThreadMetrics> iceC_IceMX_ThreadMetrics_init("::IceMX::ThreadMetrics");

const ::IceInternal::DefaultValueFactoryInit<::IceMX::DispatchMetrics> iceC_IceMX_DispatchMetrics_init("::IceMX::DispatchMetrics");

const ::IceInternal::DefaultValueFactoryInit<::IceMX::ChildInvocationMetrics> iceC_IceMX_ChildInvocationMetrics_init("::IceMX::ChildInvocationMetrics");

const ::IceInternal::DefaultValueFactoryInit<::IceMX::CollocatedMetrics> iceC_IceMX_CollocatedMetrics_init("::IceMX::CollocatedMetrics");

const ::IceInternal::DefaultValueFactoryInit<::IceMX::RemoteMetrics> iceC_IceMX_RemoteMetrics_init("::IceMX::RemoteMetrics");

const ::IceInternal::DefaultValueFactoryInit<::IceMX::InvocationMetrics> iceC_IceMX_InvocationMetrics_init("::IceMX::InvocationMetrics");

const ::IceInternal::DefaultValueFactoryInit<::IceMX::ConnectionMetrics> iceC_IceMX_ConnectionMetrics_init("::IceMX::ConnectionMetrics");

}

IceMX::UnknownMetricsView::~UnknownMetricsView()
{
}

const ::std::string&
IceMX::UnknownMetricsView::ice_staticId()
{
    static const ::std::string typeId = "::IceMX::UnknownMetricsView";
    return typeId;
}

bool
IceMX::MetricsAdmin::ice_isA(::std::string s, const ::Ice::Current&) const
{
    return ::std::binary_search(iceC_IceMX_MetricsAdmin_ids, iceC_IceMX_MetricsAdmin_ids + 2, s);
}

::std::vector<::std::string>
IceMX::MetricsAdmin::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector<::std::string>(&iceC_IceMX_MetricsAdmin_ids[0], &iceC_IceMX_MetricsAdmin_ids[2]);
}

::std::string
IceMX::MetricsAdmin::ice_id(const ::Ice::Current&) const
{
    return ice_staticId();
}

const ::std::string&
IceMX::MetricsAdmin::ice_staticId()
{
    static const ::std::string typeId = "::IceMX::MetricsAdmin";
    return typeId;
}

/// \cond INTERNAL
bool
IceMX::MetricsAdmin::_iceD_getMetricsViewNames(::IceInternal::Incoming& inS, const ::Ice::Current& current)
{
    _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
    inS.readEmptyParams();
    inS.setFormat(::Ice::FormatType::SlicedFormat);
    ::Ice::StringSeq iceP_disabledViews;
    ::Ice::StringSeq ret = this->getMetricsViewNames(iceP_disabledViews, current);
    auto ostr = inS.startWriteParams();
    ostr->writeAll(iceP_disabledViews, ret);
    inS.endWriteParams();
    return true;
}
/// \endcond

/// \cond INTERNAL
bool
IceMX::MetricsAdmin::_iceD_enableMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
{
    _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
    auto istr = inS.startReadParams();
    ::std::string iceP_name;
    istr->readAll(iceP_name);
    inS.endReadParams();
    inS.setFormat(::Ice::FormatType::SlicedFormat);
    this->enableMetricsView(::std::move(iceP_name), current);
    inS.writeEmptyParams();
    return true;
}
/// \endcond

/// \cond INTERNAL
bool
IceMX::MetricsAdmin::_iceD_disableMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
{
    _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
    auto istr = inS.startReadParams();
    ::std::string iceP_name;
    istr->readAll(iceP_name);
    inS.endReadParams();
    inS.setFormat(::Ice::FormatType::SlicedFormat);
    this->disableMetricsView(::std::move(iceP_name), current);
    inS.writeEmptyParams();
    return true;
}
/// \endcond

/// \cond INTERNAL
bool
IceMX::MetricsAdmin::_iceD_getMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
{
    _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
    auto istr = inS.startReadParams();
    ::std::string iceP_view;
    istr->readAll(iceP_view);
    inS.endReadParams();
    inS.setFormat(::Ice::FormatType::SlicedFormat);
    long long int iceP_timestamp;
    MetricsView ret = this->getMetricsView(::std::move(iceP_view), iceP_timestamp, current);
    auto ostr = inS.startWriteParams();
    ostr->writeAll(iceP_timestamp, ret);
    ostr->writePendingValues();
    inS.endWriteParams();
    return true;
}
/// \endcond

/// \cond INTERNAL
bool
IceMX::MetricsAdmin::_iceD_getMapMetricsFailures(::IceInternal::Incoming& inS, const ::Ice::Current& current)
{
    _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
    auto istr = inS.startReadParams();
    ::std::string iceP_view;
    ::std::string iceP_map;
    istr->readAll(iceP_view, iceP_map);
    inS.endReadParams();
    inS.setFormat(::Ice::FormatType::SlicedFormat);
    MetricsFailuresSeq ret = this->getMapMetricsFailures(::std::move(iceP_view), ::std::move(iceP_map), current);
    auto ostr = inS.startWriteParams();
    ostr->writeAll(ret);
    inS.endWriteParams();
    return true;
}
/// \endcond

/// \cond INTERNAL
bool
IceMX::MetricsAdmin::_iceD_getMetricsFailures(::IceInternal::Incoming& inS, const ::Ice::Current& current)
{
    _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
    auto istr = inS.startReadParams();
    ::std::string iceP_view;
    ::std::string iceP_map;
    ::std::string iceP_id;
    istr->readAll(iceP_view, iceP_map, iceP_id);
    inS.endReadParams();
    inS.setFormat(::Ice::FormatType::SlicedFormat);
    MetricsFailures ret = this->getMetricsFailures(::std::move(iceP_view), ::std::move(iceP_map), ::std::move(iceP_id), current);
    auto ostr = inS.startWriteParams();
    ostr->writeAll(ret);
    inS.endWriteParams();
    return true;
}
/// \endcond

/// \cond INTERNAL
bool
IceMX::MetricsAdmin::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_IceMX_MetricsAdmin_ops, iceC_IceMX_MetricsAdmin_ops + 10, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - iceC_IceMX_MetricsAdmin_ops)
    {
        case 0:
        {
            return _iceD_disableMetricsView(in, current);
        }
        case 1:
        {
            return _iceD_enableMetricsView(in, current);
        }
        case 2:
        {
            return _iceD_getMapMetricsFailures(in, current);
        }
        case 3:
        {
            return _iceD_getMetricsFailures(in, current);
        }
        case 4:
        {
            return _iceD_getMetricsView(in, current);
        }
        case 5:
        {
            return _iceD_getMetricsViewNames(in, current);
        }
        case 6:
        {
            return _iceD_ice_id(in, current);
        }
        case 7:
        {
            return _iceD_ice_ids(in, current);
        }
        case 8:
        {
            return _iceD_ice_isA(in, current);
        }
        case 9:
        {
            return _iceD_ice_ping(in, current);
        }
        default:
        {
            assert(false);
            throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
        }
    }
}
/// \endcond

IceMX::Metrics::~Metrics()
{
}

const ::std::string&
IceMX::Metrics::ice_staticId()
{
    static const ::std::string typeId = "::IceMX::Metrics";
    return typeId;
}

IceMX::ThreadMetrics::~ThreadMetrics()
{
}

const ::std::string&
IceMX::ThreadMetrics::ice_staticId()
{
    static const ::std::string typeId = "::IceMX::ThreadMetrics";
    return typeId;
}

IceMX::DispatchMetrics::~DispatchMetrics()
{
}

const ::std::string&
IceMX::DispatchMetrics::ice_staticId()
{
    static const ::std::string typeId = "::IceMX::DispatchMetrics";
    return typeId;
}

IceMX::ChildInvocationMetrics::~ChildInvocationMetrics()
{
}

const ::std::string&
IceMX::ChildInvocationMetrics::ice_staticId()
{
    static const ::std::string typeId = "::IceMX::ChildInvocationMetrics";
    return typeId;
}

IceMX::CollocatedMetrics::~CollocatedMetrics()
{
}

const ::std::string&
IceMX::CollocatedMetrics::ice_staticId()
{
    static const ::std::string typeId = "::IceMX::CollocatedMetrics";
    return typeId;
}

IceMX::RemoteMetrics::~RemoteMetrics()
{
}

const ::std::string&
IceMX::RemoteMetrics::ice_staticId()
{
    static const ::std::string typeId = "::IceMX::RemoteMetrics";
    return typeId;
}

IceMX::InvocationMetrics::~InvocationMetrics()
{
}

const ::std::string&
IceMX::InvocationMetrics::ice_staticId()
{
    static const ::std::string typeId = "::IceMX::InvocationMetrics";
    return typeId;
}

IceMX::ConnectionMetrics::~ConnectionMetrics()
{
}

const ::std::string&
IceMX::ConnectionMetrics::ice_staticId()
{
    static const ::std::string typeId = "::IceMX::ConnectionMetrics";
    return typeId;
}

/// \cond INTERNAL
void
IceMX::MetricsAdminPrx::_iceI_getMetricsViewNames(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<MetricsAdmin::GetMetricsViewNamesResult>>& outAsync, const ::Ice::Context& context)
{
    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMetricsViewNames_name);
    outAsync->invoke(iceC_IceMX_MetricsAdmin_getMetricsViewNames_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::SlicedFormat, context,
        nullptr,
        nullptr,
        [](::Ice::InputStream* istr)
        {
            MetricsAdmin::GetMetricsViewNamesResult v;
            istr->readAll(v.disabledViews, v.returnValue);
            return v;
        });
}
/// \endcond

/// \cond INTERNAL
void
IceMX::MetricsAdminPrx::_iceI_enableMetricsView(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>& outAsync, const ::std::string& iceP_name, const ::Ice::Context& context)
{
    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_enableMetricsView_name);
    outAsync->invoke(iceC_IceMX_MetricsAdmin_enableMetricsView_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::SlicedFormat, context,
        [&](::Ice::OutputStream* ostr)
        {
            ostr->writeAll(iceP_name);
        },
        [](const ::Ice::UserException& ex)
        {
            try
            {
                ex.ice_throw();
            }
            catch(const UnknownMetricsView&)
            {
                throw;
            }
            catch(const ::Ice::UserException&)
            {
            }
        });
}
/// \endcond

/// \cond INTERNAL
void
IceMX::MetricsAdminPrx::_iceI_disableMetricsView(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>& outAsync, const ::std::string& iceP_name, const ::Ice::Context& context)
{
    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_disableMetricsView_name);
    outAsync->invoke(iceC_IceMX_MetricsAdmin_disableMetricsView_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::SlicedFormat, context,
        [&](::Ice::OutputStream* ostr)
        {
            ostr->writeAll(iceP_name);
        },
        [](const ::Ice::UserException& ex)
        {
            try
            {
                ex.ice_throw();
            }
            catch(const UnknownMetricsView&)
            {
                throw;
            }
            catch(const ::Ice::UserException&)
            {
            }
        });
}
/// \endcond

/// \cond INTERNAL
void
IceMX::MetricsAdminPrx::_iceI_getMetricsView(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<MetricsAdmin::GetMetricsViewResult>>& outAsync, const ::std::string& iceP_view, const ::Ice::Context& context)
{
    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMetricsView_name);
    outAsync->invoke(iceC_IceMX_MetricsAdmin_getMetricsView_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::SlicedFormat, context,
        [&](::Ice::OutputStream* ostr)
        {
            ostr->writeAll(iceP_view);
        },
        [](const ::Ice::UserException& ex)
        {
            try
            {
                ex.ice_throw();
            }
            catch(const UnknownMetricsView&)
            {
                throw;
            }
            catch(const ::Ice::UserException&)
            {
            }
        },
        [](::Ice::InputStream* istr)
        {
            MetricsAdmin::GetMetricsViewResult v;
            istr->readAll(v.timestamp, v.returnValue);
            istr->readPendingValues();
            return v;
        });
}
/// \endcond

/// \cond INTERNAL
void
IceMX::MetricsAdminPrx::_iceI_getMapMetricsFailures(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::IceMX::MetricsFailuresSeq>>& outAsync, const ::std::string& iceP_view, const ::std::string& iceP_map, const ::Ice::Context& context)
{
    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name);
    outAsync->invoke(iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::SlicedFormat, context,
        [&](::Ice::OutputStream* ostr)
        {
            ostr->writeAll(iceP_view, iceP_map);
        },
        [](const ::Ice::UserException& ex)
        {
            try
            {
                ex.ice_throw();
            }
            catch(const UnknownMetricsView&)
            {
                throw;
            }
            catch(const ::Ice::UserException&)
            {
            }
        });
}
/// \endcond

/// \cond INTERNAL
void
IceMX::MetricsAdminPrx::_iceI_getMetricsFailures(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::IceMX::MetricsFailures>>& outAsync, const ::std::string& iceP_view, const ::std::string& iceP_map, const ::std::string& iceP_id, const ::Ice::Context& context)
{
    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMetricsFailures_name);
    outAsync->invoke(iceC_IceMX_MetricsAdmin_getMetricsFailures_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::SlicedFormat, context,
        [&](::Ice::OutputStream* ostr)
        {
            ostr->writeAll(iceP_view, iceP_map, iceP_id);
        },
        [](const ::Ice::UserException& ex)
        {
            try
            {
                ex.ice_throw();
            }
            catch(const UnknownMetricsView&)
            {
                throw;
            }
            catch(const ::Ice::UserException&)
            {
            }
        });
}
/// \endcond

/// \cond INTERNAL
::std::shared_ptr<::Ice::ObjectPrx>
IceMX::MetricsAdminPrx::_newInstance() const
{
    return ::IceInternal::createProxy<MetricsAdminPrx>();
}
/// \endcond

const ::std::string&
IceMX::MetricsAdminPrx::ice_staticId()
{
    return MetricsAdmin::ice_staticId();
}

namespace Ice
{
}

#else // C++98 mapping

namespace
{

const ::std::string iceC_IceMX_MetricsAdmin_getMetricsViewNames_name = "getMetricsViewNames";

const ::std::string iceC_IceMX_MetricsAdmin_enableMetricsView_name = "enableMetricsView";

const ::std::string iceC_IceMX_MetricsAdmin_disableMetricsView_name = "disableMetricsView";

const ::std::string iceC_IceMX_MetricsAdmin_getMetricsView_name = "getMetricsView";

const ::std::string iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name = "getMapMetricsFailures";

const ::std::string iceC_IceMX_MetricsAdmin_getMetricsFailures_name = "getMetricsFailures";

}

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceMX::UnknownMetricsView> iceC_IceMX_UnknownMetricsView_init("::IceMX::UnknownMetricsView");

}

#ifdef ICE_CPP11_COMPILER
IceMX::UnknownMetricsView::~UnknownMetricsView()
{
}
#else
IceMX::UnknownMetricsView::~UnknownMetricsView() throw()
{
}
#endif

::std::string
IceMX::UnknownMetricsView::ice_id() const
{
    return "::IceMX::UnknownMetricsView";
}

IceMX::UnknownMetricsView*
IceMX::UnknownMetricsView::ice_clone() const
{
    return new UnknownMetricsView(*this);
}

void
IceMX::UnknownMetricsView::ice_throw() const
{
    throw *this;
}

/// \cond STREAM
void
IceMX::UnknownMetricsView::_writeImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice("::IceMX::UnknownMetricsView", -1, true);
    ::Ice::StreamWriter< UnknownMetricsView, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceMX::UnknownMetricsView::_readImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< UnknownMetricsView, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

/// \cond INTERNAL
ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(Metrics* p) { return p; }

void
::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< Metrics>& v)
{
    ::Ice::ObjectPrx proxy;
    istr->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new Metrics;
        v->_copyFrom(proxy);
    }
}
/// \endcond

/// \cond INTERNAL
::IceProxy::Ice::Object*
IceProxy::IceMX::Metrics::_newInstance() const
{
    return new Metrics;
}
/// \endcond

const ::std::string&
IceProxy::IceMX::Metrics::ice_staticId()
{
    return ::IceMX::Metrics::ice_staticId();
}

/// \cond INTERNAL
ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(MetricsAdmin* p) { return p; }

void
::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< MetricsAdmin>& v)
{
    ::Ice::ObjectPrx proxy;
    istr->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new MetricsAdmin;
        v->_copyFrom(proxy);
    }
}
/// \endcond

::Ice::AsyncResultPtr
IceProxy::IceMX::MetricsAdmin::_iceI_begin_getMetricsViewNames(const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
{
    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMetricsViewNames_name, sync);
    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceMX_MetricsAdmin_getMetricsViewNames_name, del, cookie, sync);
    try
    {
        result->prepare(iceC_IceMX_MetricsAdmin_getMetricsViewNames_name, ::Ice::Normal, context);
        result->writeEmptyParams();
        result->invoke(iceC_IceMX_MetricsAdmin_getMetricsViewNames_name);
    }
    catch(const ::Ice::Exception& ex)
    {
        result->abort(ex);
    }
    return result;
}

::Ice::StringSeq
IceProxy::IceMX::MetricsAdmin::end_getMetricsViewNames(::Ice::StringSeq& iceP_disabledViews, const ::Ice::AsyncResultPtr& result)
{
    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_getMetricsViewNames_name);
    ::Ice::StringSeq ret;
    if(!result->_waitForResponse())
    {
        try
        {
            result->_throwUserException();
        }
        catch(const ::Ice::UserException& ex)
        {
            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
        }
    }
    ::Ice::InputStream* istr = result->_startReadParams();
    istr->read(iceP_disabledViews);
    istr->read(ret);
    result->_endReadParams();
    return ret;
}

void IceProxy::IceMX::MetricsAdmin::_iceI_end_getMetricsViewNames(::Ice::StringSeq& iceP_disabledViews, ::Ice::StringSeq& ret, const ::Ice::AsyncResultPtr& result)
{
    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_getMetricsViewNames_name);
    if(!result->_waitForResponse())
    {
        try
        {
            result->_throwUserException();
        }
        catch(const ::Ice::UserException& ex)
        {
            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
        }
    }
    ::Ice::InputStream* istr = result->_startReadParams();
    istr->read(iceP_disabledViews);
    istr->read(ret);
    result->_endReadParams();
}

::Ice::AsyncResultPtr
IceProxy::IceMX::MetricsAdmin::_iceI_begin_enableMetricsView(const ::std::string& iceP_name, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
{
    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_enableMetricsView_name, sync);
    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceMX_MetricsAdmin_enableMetricsView_name, del, cookie, sync);
    try
    {
        result->prepare(iceC_IceMX_MetricsAdmin_enableMetricsView_name, ::Ice::Normal, context);
        ::Ice::OutputStream* ostr = result->startWriteParams(::Ice::SlicedFormat);
        ostr->write(iceP_name);
        result->endWriteParams();
        result->invoke(iceC_IceMX_MetricsAdmin_enableMetricsView_name);
    }
    catch(const ::Ice::Exception& ex)
    {
        result->abort(ex);
    }
    return result;
}

void
IceProxy::IceMX::MetricsAdmin::end_enableMetricsView(const ::Ice::AsyncResultPtr& result)
{
    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_enableMetricsView_name);
    if(!result->_waitForResponse())
    {
        try
        {
            result->_throwUserException();
        }
        catch(const ::IceMX::UnknownMetricsView&)
        {
            throw;
        }
        catch(const ::Ice::UserException& ex)
        {
            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
        }
    }
    result->_readEmptyParams();
}

::Ice::AsyncResultPtr
IceProxy::IceMX::MetricsAdmin::_iceI_begin_disableMetricsView(const ::std::string& iceP_name, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
{
    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_disableMetricsView_name, sync);
    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceMX_MetricsAdmin_disableMetricsView_name, del, cookie, sync);
    try
    {
        result->prepare(iceC_IceMX_MetricsAdmin_disableMetricsView_name, ::Ice::Normal, context);
        ::Ice::OutputStream* ostr = result->startWriteParams(::Ice::SlicedFormat);
        ostr->write(iceP_name);
        result->endWriteParams();
        result->invoke(iceC_IceMX_MetricsAdmin_disableMetricsView_name);
    }
    catch(const ::Ice::Exception& ex)
    {
        result->abort(ex);
    }
    return result;
}

void
IceProxy::IceMX::MetricsAdmin::end_disableMetricsView(const ::Ice::AsyncResultPtr& result)
{
    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_disableMetricsView_name);
    if(!result->_waitForResponse())
    {
        try
        {
            result->_throwUserException();
        }
        catch(const ::IceMX::UnknownMetricsView&)
        {
            throw;
        }
        catch(const ::Ice::UserException& ex)
        {
            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
        }
    }
    result->_readEmptyParams();
}

::Ice::AsyncResultPtr
IceProxy::IceMX::MetricsAdmin::_iceI_begin_getMetricsView(const ::std::string& iceP_view, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
{
    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMetricsView_name, sync);
    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceMX_MetricsAdmin_getMetricsView_name, del, cookie, sync);
    try
    {
        result->prepare(iceC_IceMX_MetricsAdmin_getMetricsView_name, ::Ice::Normal, context);
        ::Ice::OutputStream* ostr = result->startWriteParams(::Ice::SlicedFormat);
        ostr->write(iceP_view);
        result->endWriteParams();
        result->invoke(iceC_IceMX_MetricsAdmin_getMetricsView_name);
    }
    catch(const ::Ice::Exception& ex)
    {
        result->abort(ex);
    }
    return result;
}

::IceMX::MetricsView
IceProxy::IceMX::MetricsAdmin::end_getMetricsView(::Ice::Long& iceP_timestamp, const ::Ice::AsyncResultPtr& result)
{
    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_getMetricsView_name);
    ::IceMX::MetricsView ret;
    if(!result->_waitForResponse())
    {
        try
        {
            result->_throwUserException();
        }
        catch(const ::IceMX::UnknownMetricsView&)
        {
            throw;
        }
        catch(const ::Ice::UserException& ex)
        {
            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
        }
    }
    ::Ice::InputStream* istr = result->_startReadParams();
    istr->read(iceP_timestamp);
    istr->read(ret);
    istr->readPendingValues();
    result->_endReadParams();
    return ret;
}

void IceProxy::IceMX::MetricsAdmin::_iceI_end_getMetricsView(::Ice::Long& iceP_timestamp, ::IceMX::MetricsView& ret, const ::Ice::AsyncResultPtr& result)
{
    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_getMetricsView_name);
    if(!result->_waitForResponse())
    {
        try
        {
            result->_throwUserException();
        }
        catch(const ::IceMX::UnknownMetricsView&)
        {
            throw;
        }
        catch(const ::Ice::UserException& ex)
        {
            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
        }
    }
    ::Ice::InputStream* istr = result->_startReadParams();
    istr->read(iceP_timestamp);
    istr->read(ret);
    istr->readPendingValues();
    result->_endReadParams();
}

::Ice::AsyncResultPtr
IceProxy::IceMX::MetricsAdmin::_iceI_begin_getMapMetricsFailures(const ::std::string& iceP_view, const ::std::string& iceP_map, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
{
    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name, sync);
    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name, del, cookie, sync);
    try
    {
        result->prepare(iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name, ::Ice::Normal, context);
        ::Ice::OutputStream* ostr = result->startWriteParams(::Ice::SlicedFormat);
        ostr->write(iceP_view);
        ostr->write(iceP_map);
        result->endWriteParams();
        result->invoke(iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name);
    }
    catch(const ::Ice::Exception& ex)
    {
        result->abort(ex);
    }
    return result;
}

::IceMX::MetricsFailuresSeq
IceProxy::IceMX::MetricsAdmin::end_getMapMetricsFailures(const ::Ice::AsyncResultPtr& result)
{
    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name);
    ::IceMX::MetricsFailuresSeq ret;
    if(!result->_waitForResponse())
    {
        try
        {
            result->_throwUserException();
        }
        catch(const ::IceMX::UnknownMetricsView&)
        {
            throw;
        }
        catch(const ::Ice::UserException& ex)
        {
            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
        }
    }
    ::Ice::InputStream* istr = result->_startReadParams();
    istr->read(ret);
    result->_endReadParams();
    return ret;
}

::Ice::AsyncResultPtr
IceProxy::IceMX::MetricsAdmin::_iceI_begin_getMetricsFailures(const ::std::string& iceP_view, const ::std::string& iceP_map, const ::std::string& iceP_id, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
{
    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMetricsFailures_name, sync);
    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceMX_MetricsAdmin_getMetricsFailures_name, del, cookie, sync);
    try
    {
        result->prepare(iceC_IceMX_MetricsAdmin_getMetricsFailures_name, ::Ice::Normal, context);
        ::Ice::OutputStream* ostr = result->startWriteParams(::Ice::SlicedFormat);
        ostr->write(iceP_view);
        ostr->write(iceP_map);
        ostr->write(iceP_id);
        result->endWriteParams();
        result->invoke(iceC_IceMX_MetricsAdmin_getMetricsFailures_name);
    }
    catch(const ::Ice::Exception& ex)
    {
        result->abort(ex);
    }
    return result;
}

::IceMX::MetricsFailures
IceProxy::IceMX::MetricsAdmin::end_getMetricsFailures(const ::Ice::AsyncResultPtr& result)
{
    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_getMetricsFailures_name);
    ::IceMX::MetricsFailures ret;
    if(!result->_waitForResponse())
    {
        try
        {
            result->_throwUserException();
        }
        catch(const ::IceMX::UnknownMetricsView&)
        {
            throw;
        }
        catch(const ::Ice::UserException& ex)
        {
            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
        }
    }
    ::Ice::InputStream* istr = result->_startReadParams();
    istr->read(ret);
    result->_endReadParams();
    return ret;
}

/// \cond INTERNAL
::IceProxy::Ice::Object*
IceProxy::IceMX::MetricsAdmin::_newInstance() const
{
    return new MetricsAdmin;
}
/// \endcond

const ::std::string&
IceProxy::IceMX::MetricsAdmin::ice_staticId()
{
    return ::IceMX::MetricsAdmin::ice_staticId();
}

/// \cond INTERNAL
ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(ThreadMetrics* p) { return p; }

void
::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ThreadMetrics>& v)
{
    ::Ice::ObjectPrx proxy;
    istr->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ThreadMetrics;
        v->_copyFrom(proxy);
    }
}
/// \endcond

/// \cond INTERNAL
::IceProxy::Ice::Object*
IceProxy::IceMX::ThreadMetrics::_newInstance() const
{
    return new ThreadMetrics;
}
/// \endcond

const ::std::string&
IceProxy::IceMX::ThreadMetrics::ice_staticId()
{
    return ::IceMX::ThreadMetrics::ice_staticId();
}

/// \cond INTERNAL
ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(DispatchMetrics* p) { return p; }

void
::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< DispatchMetrics>& v)
{
    ::Ice::ObjectPrx proxy;
    istr->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new DispatchMetrics;
        v->_copyFrom(proxy);
    }
}
/// \endcond

/// \cond INTERNAL
::IceProxy::Ice::Object*
IceProxy::IceMX::DispatchMetrics::_newInstance() const
{
    return new DispatchMetrics;
}
/// \endcond

const ::std::string&
IceProxy::IceMX::DispatchMetrics::ice_staticId()
{
    return ::IceMX::DispatchMetrics::ice_staticId();
}

/// \cond INTERNAL
ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(ChildInvocationMetrics* p) { return p; }

void
::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ChildInvocationMetrics>& v)
{
    ::Ice::ObjectPrx proxy;
    istr->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ChildInvocationMetrics;
        v->_copyFrom(proxy);
    }
}
/// \endcond

/// \cond INTERNAL
::IceProxy::Ice::Object*
IceProxy::IceMX::ChildInvocationMetrics::_newInstance() const
{
    return new ChildInvocationMetrics;
}
/// \endcond

const ::std::string&
IceProxy::IceMX::ChildInvocationMetrics::ice_staticId()
{
    return ::IceMX::ChildInvocationMetrics::ice_staticId();
}

/// \cond INTERNAL
ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(CollocatedMetrics* p) { return p; }

void
::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< CollocatedMetrics>& v)
{
    ::Ice::ObjectPrx proxy;
    istr->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new CollocatedMetrics;
        v->_copyFrom(proxy);
    }
}
/// \endcond

/// \cond INTERNAL
::IceProxy::Ice::Object*
IceProxy::IceMX::CollocatedMetrics::_newInstance() const
{
    return new CollocatedMetrics;
}
/// \endcond

const ::std::string&
IceProxy::IceMX::CollocatedMetrics::ice_staticId()
{
    return ::IceMX::CollocatedMetrics::ice_staticId();
}

/// \cond INTERNAL
ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(RemoteMetrics* p) { return p; }

void
::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< RemoteMetrics>& v)
{
    ::Ice::ObjectPrx proxy;
    istr->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new RemoteMetrics;
        v->_copyFrom(proxy);
    }
}
/// \endcond

/// \cond INTERNAL
::IceProxy::Ice::Object*
IceProxy::IceMX::RemoteMetrics::_newInstance() const
{
    return new RemoteMetrics;
}
/// \endcond

const ::std::string&
IceProxy::IceMX::RemoteMetrics::ice_staticId()
{
    return ::IceMX::RemoteMetrics::ice_staticId();
}

/// \cond INTERNAL
ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(InvocationMetrics* p) { return p; }

void
::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< InvocationMetrics>& v)
{
    ::Ice::ObjectPrx proxy;
    istr->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new InvocationMetrics;
        v->_copyFrom(proxy);
    }
}
/// \endcond

/// \cond INTERNAL
::IceProxy::Ice::Object*
IceProxy::IceMX::InvocationMetrics::_newInstance() const
{
    return new InvocationMetrics;
}
/// \endcond

const ::std::string&
IceProxy::IceMX::InvocationMetrics::ice_staticId()
{
    return ::IceMX::InvocationMetrics::ice_staticId();
}

/// \cond INTERNAL
ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(ConnectionMetrics* p) { return p; }

void
::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ConnectionMetrics>& v)
{
    ::Ice::ObjectPrx proxy;
    istr->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ConnectionMetrics;
        v->_copyFrom(proxy);
    }
}
/// \endcond

/// \cond INTERNAL
::IceProxy::Ice::Object*
IceProxy::IceMX::ConnectionMetrics::_newInstance() const
{
    return new ConnectionMetrics;
}
/// \endcond

const ::std::string&
IceProxy::IceMX::ConnectionMetrics::ice_staticId()
{
    return ::IceMX::ConnectionMetrics::ice_staticId();
}

IceMX::Metrics::~Metrics()
{
}

/// \cond INTERNAL
ICE_API ::Ice::Object* IceMX::upCast(Metrics* p) { return p; }

/// \endcond
::Ice::ObjectPtr
IceMX::Metrics::ice_clone() const
{
    ::Ice::Object* p = new Metrics(*this);
    return p;
}

namespace
{
const ::std::string iceC_IceMX_Metrics_ids[2] =
{
    "::Ice::Object",
    "::IceMX::Metrics"
};

}

bool
IceMX::Metrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
{
    return ::std::binary_search(iceC_IceMX_Metrics_ids, iceC_IceMX_Metrics_ids + 2, s);
}

::std::vector< ::std::string>
IceMX::Metrics::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&iceC_IceMX_Metrics_ids[0], &iceC_IceMX_Metrics_ids[2]);
}

const ::std::string&
IceMX::Metrics::ice_id(const ::Ice::Current&) const
{
    return ice_staticId();
}

const ::std::string&
IceMX::Metrics::ice_staticId()
{
#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
    static const ::std::string typeId = "::IceMX::Metrics";
    return typeId;
#else
    return iceC_IceMX_Metrics_ids[1];
#endif
}

/// \cond STREAM
void
IceMX::Metrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice(ice_staticId(), -1, true);
    ::Ice::StreamWriter< Metrics, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceMX::Metrics::_iceReadImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< Metrics, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

namespace
{
const ::IceInternal::DefaultValueFactoryInit< ::IceMX::Metrics> iceC_IceMX_Metrics_init("::IceMX::Metrics");
}

::Ice::ValueFactoryPtr
IceMX::Metrics::ice_factory()
{
    return ::IceInternal::factoryTable->getValueFactory(::IceMX::Metrics::ice_staticId());
}

/// \cond INTERNAL
void
IceMX::_icePatchObjectPtr(MetricsPtr& handle, const ::Ice::ObjectPtr& v)
{
    handle = MetricsPtr::dynamicCast(v);
    if(v && !handle)
    {
        IceInternal::Ex::throwUOE(Metrics::ice_staticId(), v);
    }
}
/// \endcond

IceMX::MetricsAdmin::~MetricsAdmin()
{
}

/// \cond INTERNAL
ICE_API ::Ice::Object* IceMX::upCast(MetricsAdmin* p) { return p; }

/// \endcond

namespace
{
const ::std::string iceC_IceMX_MetricsAdmin_ids[2] =
{
    "::Ice::Object",
    "::IceMX::MetricsAdmin"
};

}

bool
IceMX::MetricsAdmin::ice_isA(const ::std::string& s, const ::Ice::Current&) const
{
    return ::std::binary_search(iceC_IceMX_MetricsAdmin_ids, iceC_IceMX_MetricsAdmin_ids + 2, s);
}

::std::vector< ::std::string>
IceMX::MetricsAdmin::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&iceC_IceMX_MetricsAdmin_ids[0], &iceC_IceMX_MetricsAdmin_ids[2]);
}

const ::std::string&
IceMX::MetricsAdmin::ice_id(const ::Ice::Current&) const
{
    return ice_staticId();
}

const ::std::string&
IceMX::MetricsAdmin::ice_staticId()
{
#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
    static const ::std::string typeId = "::IceMX::MetricsAdmin";
    return typeId;
#else
    return iceC_IceMX_MetricsAdmin_ids[1];
#endif
}

/// \cond INTERNAL
bool
IceMX::MetricsAdmin::_iceD_getMetricsViewNames(::IceInternal::Incoming& inS, const ::Ice::Current& current)
{
    _iceCheckMode(::Ice::Normal, current.mode);
    inS.readEmptyParams();
    inS.setFormat(::Ice::SlicedFormat);
    ::Ice::StringSeq iceP_disabledViews;
    ::Ice::StringSeq ret = this->getMetricsViewNames(iceP_disabledViews, current);
    ::Ice::OutputStream* ostr = inS.startWriteParams();
    ostr->write(iceP_disabledViews);
    ostr->write(ret);
    inS.endWriteParams();
    return true;
}
/// \endcond

/// \cond INTERNAL
bool
IceMX::MetricsAdmin::_iceD_enableMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
{
    _iceCheckMode(::Ice::Normal, current.mode);
    ::Ice::InputStream* istr = inS.startReadParams();
    ::std::string iceP_name;
    istr->read(iceP_name);
    inS.endReadParams();
    inS.setFormat(::Ice::SlicedFormat);
    this->enableMetricsView(iceP_name, current);
    inS.writeEmptyParams();
    return true;
}
/// \endcond

/// \cond INTERNAL
bool
IceMX::MetricsAdmin::_iceD_disableMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
{
    _iceCheckMode(::Ice::Normal, current.mode);
    ::Ice::InputStream* istr = inS.startReadParams();
    ::std::string iceP_name;
    istr->read(iceP_name);
    inS.endReadParams();
    inS.setFormat(::Ice::SlicedFormat);
    this->disableMetricsView(iceP_name, current);
    inS.writeEmptyParams();
    return true;
}
/// \endcond

/// \cond INTERNAL
bool
IceMX::MetricsAdmin::_iceD_getMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
{
    _iceCheckMode(::Ice::Normal, current.mode);
    ::Ice::InputStream* istr = inS.startReadParams();
    ::std::string iceP_view;
    istr->read(iceP_view);
    inS.endReadParams();
    inS.setFormat(::Ice::SlicedFormat);
    ::Ice::Long iceP_timestamp;
    MetricsView ret = this->getMetricsView(iceP_view, iceP_timestamp, current);
    ::Ice::OutputStream* ostr = inS.startWriteParams();
    ostr->write(iceP_timestamp);
    ostr->write(ret);
    ostr->writePendingValues();
    inS.endWriteParams();
    return true;
}
/// \endcond

/// \cond INTERNAL
bool
IceMX::MetricsAdmin::_iceD_getMapMetricsFailures(::IceInternal::Incoming& inS, const ::Ice::Current& current)
{
    _iceCheckMode(::Ice::Normal, current.mode);
    ::Ice::InputStream* istr = inS.startReadParams();
    ::std::string iceP_view;
    ::std::string iceP_map;
    istr->read(iceP_view);
    istr->read(iceP_map);
    inS.endReadParams();
    inS.setFormat(::Ice::SlicedFormat);
    MetricsFailuresSeq ret = this->getMapMetricsFailures(iceP_view, iceP_map, current);
    ::Ice::OutputStream* ostr = inS.startWriteParams();
    ostr->write(ret);
    inS.endWriteParams();
    return true;
}
/// \endcond

/// \cond INTERNAL
bool
IceMX::MetricsAdmin::_iceD_getMetricsFailures(::IceInternal::Incoming& inS, const ::Ice::Current& current)
{
    _iceCheckMode(::Ice::Normal, current.mode);
    ::Ice::InputStream* istr = inS.startReadParams();
    ::std::string iceP_view;
    ::std::string iceP_map;
    ::std::string iceP_id;
    istr->read(iceP_view);
    istr->read(iceP_map);
    istr->read(iceP_id);
    inS.endReadParams();
    inS.setFormat(::Ice::SlicedFormat);
    MetricsFailures ret = this->getMetricsFailures(iceP_view, iceP_map, iceP_id, current);
    ::Ice::OutputStream* ostr = inS.startWriteParams();
    ostr->write(ret);
    inS.endWriteParams();
    return true;
}
/// \endcond

namespace
{
const ::std::string iceC_IceMX_MetricsAdmin_all[] =
{
    "disableMetricsView",
    "enableMetricsView",
    "getMapMetricsFailures",
    "getMetricsFailures",
    "getMetricsView",
    "getMetricsViewNames",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping"
};

}

/// \cond INTERNAL
bool
IceMX::MetricsAdmin::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_IceMX_MetricsAdmin_all, iceC_IceMX_MetricsAdmin_all + 10, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - iceC_IceMX_MetricsAdmin_all)
    {
        case 0:
        {
            return _iceD_disableMetricsView(in, current);
        }
        case 1:
        {
            return _iceD_enableMetricsView(in, current);
        }
        case 2:
        {
            return _iceD_getMapMetricsFailures(in, current);
        }
        case 3:
        {
            return _iceD_getMetricsFailures(in, current);
        }
        case 4:
        {
            return _iceD_getMetricsView(in, current);
        }
        case 5:
        {
            return _iceD_getMetricsViewNames(in, current);
        }
        case 6:
        {
            return _iceD_ice_id(in, current);
        }
        case 7:
        {
            return _iceD_ice_ids(in, current);
        }
        case 8:
        {
            return _iceD_ice_isA(in, current);
        }
        case 9:
        {
            return _iceD_ice_ping(in, current);
        }
        default:
        {
            assert(false);
            throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
        }
    }
}
/// \endcond

/// \cond STREAM
void
IceMX::MetricsAdmin::_iceWriteImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice(ice_staticId(), -1, true);
    ::Ice::StreamWriter< MetricsAdmin, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceMX::MetricsAdmin::_iceReadImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< MetricsAdmin, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

/// \cond INTERNAL
void
IceMX::_icePatchObjectPtr(MetricsAdminPtr& handle, const ::Ice::ObjectPtr& v)
{
    handle = MetricsAdminPtr::dynamicCast(v);
    if(v && !handle)
    {
        IceInternal::Ex::throwUOE(MetricsAdmin::ice_staticId(), v);
    }
}
/// \endcond

IceMX::ThreadMetrics::~ThreadMetrics()
{
}

/// \cond INTERNAL
ICE_API ::Ice::Object* IceMX::upCast(ThreadMetrics* p) { return p; }

/// \endcond
::Ice::ObjectPtr
IceMX::ThreadMetrics::ice_clone() const
{
    ::Ice::Object* p = new ThreadMetrics(*this);
    return p;
}

namespace
{
const ::std::string iceC_IceMX_ThreadMetrics_ids[3] =
{
    "::Ice::Object",
    "::IceMX::Metrics",
    "::IceMX::ThreadMetrics"
};

}

bool
IceMX::ThreadMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
{
    return ::std::binary_search(iceC_IceMX_ThreadMetrics_ids, iceC_IceMX_ThreadMetrics_ids + 3, s);
}

::std::vector< ::std::string>
IceMX::ThreadMetrics::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&iceC_IceMX_ThreadMetrics_ids[0], &iceC_IceMX_ThreadMetrics_ids[3]);
}

const ::std::string&
IceMX::ThreadMetrics::ice_id(const ::Ice::Current&) const
{
    return ice_staticId();
}

const ::std::string&
IceMX::ThreadMetrics::ice_staticId()
{
#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
    static const ::std::string typeId = "::IceMX::ThreadMetrics";
    return typeId;
#else
    return iceC_IceMX_ThreadMetrics_ids[2];
#endif
}

/// \cond STREAM
void
IceMX::ThreadMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice(ice_staticId(), -1, false);
    ::Ice::StreamWriter< ThreadMetrics, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
    Metrics::_iceWriteImpl(ostr);
}

void
IceMX::ThreadMetrics::_iceReadImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< ThreadMetrics, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
    Metrics::_iceReadImpl(istr);
}
/// \endcond

namespace
{
const ::IceInternal::DefaultValueFactoryInit< ::IceMX::ThreadMetrics> iceC_IceMX_ThreadMetrics_init("::IceMX::ThreadMetrics");
}

::Ice::ValueFactoryPtr
IceMX::ThreadMetrics::ice_factory()
{
    return ::IceInternal::factoryTable->getValueFactory(::IceMX::ThreadMetrics::ice_staticId());
}

/// \cond INTERNAL
void
IceMX::_icePatchObjectPtr(ThreadMetricsPtr& handle, const ::Ice::ObjectPtr& v)
{
    handle = ThreadMetricsPtr::dynamicCast(v);
    if(v && !handle)
    {
        IceInternal::Ex::throwUOE(ThreadMetrics::ice_staticId(), v);
    }
}
/// \endcond

IceMX::DispatchMetrics::~DispatchMetrics()
{
}

/// \cond INTERNAL
ICE_API ::Ice::Object* IceMX::upCast(DispatchMetrics* p) { return p; }

/// \endcond
::Ice::ObjectPtr
IceMX::DispatchMetrics::ice_clone() const
{
    ::Ice::Object* p = new DispatchMetrics(*this);
    return p;
}

namespace
{
const ::std::string iceC_IceMX_DispatchMetrics_ids[3] =
{
    "::Ice::Object",
    "::IceMX::DispatchMetrics",
    "::IceMX::Metrics"
};

}

bool
IceMX::DispatchMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
{
    return ::std::binary_search(iceC_IceMX_DispatchMetrics_ids, iceC_IceMX_DispatchMetrics_ids + 3, s);
}

::std::vector< ::std::string>
IceMX::DispatchMetrics::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&iceC_IceMX_DispatchMetrics_ids[0], &iceC_IceMX_DispatchMetrics_ids[3]);
}

const ::std::string&
IceMX::DispatchMetrics::ice_id(const ::Ice::Current&) const
{
    return ice_staticId();
}

const ::std::string&
IceMX::DispatchMetrics::ice_staticId()
{
#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
    static const ::std::string typeId = "::IceMX::DispatchMetrics";
    return typeId;
#else
    return iceC_IceMX_DispatchMetrics_ids[1];
#endif
}

/// \cond STREAM
void
IceMX::DispatchMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice(ice_staticId(), -1, false);
    ::Ice::StreamWriter< DispatchMetrics, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
    Metrics::_iceWriteImpl(ostr);
}

void
IceMX::DispatchMetrics::_iceReadImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< DispatchMetrics, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
    Metrics::_iceReadImpl(istr);
}
/// \endcond

namespace
{
const ::IceInternal::DefaultValueFactoryInit< ::IceMX::DispatchMetrics> iceC_IceMX_DispatchMetrics_init("::IceMX::DispatchMetrics");
}

::Ice::ValueFactoryPtr
IceMX::DispatchMetrics::ice_factory()
{
    return ::IceInternal::factoryTable->getValueFactory(::IceMX::DispatchMetrics::ice_staticId());
}

/// \cond INTERNAL
void
IceMX::_icePatchObjectPtr(DispatchMetricsPtr& handle, const ::Ice::ObjectPtr& v)
{
    handle = DispatchMetricsPtr::dynamicCast(v);
    if(v && !handle)
    {
        IceInternal::Ex::throwUOE(DispatchMetrics::ice_staticId(), v);
    }
}
/// \endcond

IceMX::ChildInvocationMetrics::~ChildInvocationMetrics()
{
}

/// \cond INTERNAL
ICE_API ::Ice::Object* IceMX::upCast(ChildInvocationMetrics* p) { return p; }

/// \endcond
::Ice::ObjectPtr
IceMX::ChildInvocationMetrics::ice_clone() const
{
    ::Ice::Object* p = new ChildInvocationMetrics(*this);
    return p;
}

namespace
{
const ::std::string iceC_IceMX_ChildInvocationMetrics_ids[3] =
{
    "::Ice::Object",
    "::IceMX::ChildInvocationMetrics",
    "::IceMX::Metrics"
};

}

bool
IceMX::ChildInvocationMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
{
    return ::std::binary_search(iceC_IceMX_ChildInvocationMetrics_ids, iceC_IceMX_ChildInvocationMetrics_ids + 3, s);
}

::std::vector< ::std::string>
IceMX::ChildInvocationMetrics::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&iceC_IceMX_ChildInvocationMetrics_ids[0], &iceC_IceMX_ChildInvocationMetrics_ids[3]);
}

const ::std::string&
IceMX::ChildInvocationMetrics::ice_id(const ::Ice::Current&) const
{
    return ice_staticId();
}

const ::std::string&
IceMX::ChildInvocationMetrics::ice_staticId()
{
#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
    static const ::std::string typeId = "::IceMX::ChildInvocationMetrics";
    return typeId;
#else
    return iceC_IceMX_ChildInvocationMetrics_ids[1];
#endif
}

/// \cond STREAM
void
IceMX::ChildInvocationMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice(ice_staticId(), -1, false);
    ::Ice::StreamWriter< ChildInvocationMetrics, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
    Metrics::_iceWriteImpl(ostr);
}

void
IceMX::ChildInvocationMetrics::_iceReadImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< ChildInvocationMetrics, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
    Metrics::_iceReadImpl(istr);
}
/// \endcond

namespace
{
const ::IceInternal::DefaultValueFactoryInit< ::IceMX::ChildInvocationMetrics> iceC_IceMX_ChildInvocationMetrics_init("::IceMX::ChildInvocationMetrics");
}

::Ice::ValueFactoryPtr
IceMX::ChildInvocationMetrics::ice_factory()
{
    return ::IceInternal::factoryTable->getValueFactory(::IceMX::ChildInvocationMetrics::ice_staticId());
}

/// \cond INTERNAL
void
IceMX::_icePatchObjectPtr(ChildInvocationMetricsPtr& handle, const ::Ice::ObjectPtr& v)
{
    handle = ChildInvocationMetricsPtr::dynamicCast(v);
    if(v && !handle)
    {
        IceInternal::Ex::throwUOE(ChildInvocationMetrics::ice_staticId(), v);
    }
}
/// \endcond

IceMX::CollocatedMetrics::~CollocatedMetrics()
{
}

/// \cond INTERNAL
ICE_API ::Ice::Object* IceMX::upCast(CollocatedMetrics* p) { return p; }

/// \endcond
::Ice::ObjectPtr
IceMX::CollocatedMetrics::ice_clone() const
{
    ::Ice::Object* p = new CollocatedMetrics(*this);
    return p;
}

namespace
{
const ::std::string iceC_IceMX_CollocatedMetrics_ids[4] =
{
    "::Ice::Object",
    "::IceMX::ChildInvocationMetrics",
    "::IceMX::CollocatedMetrics",
    "::IceMX::Metrics"
};

}

bool
IceMX::CollocatedMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
{
    return ::std::binary_search(iceC_IceMX_CollocatedMetrics_ids, iceC_IceMX_CollocatedMetrics_ids + 4, s);
}

::std::vector< ::std::string>
IceMX::CollocatedMetrics::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&iceC_IceMX_CollocatedMetrics_ids[0], &iceC_IceMX_CollocatedMetrics_ids[4]);
}

const ::std::string&
IceMX::CollocatedMetrics::ice_id(const ::Ice::Current&) const
{
    return ice_staticId();
}

const ::std::string&
IceMX::CollocatedMetrics::ice_staticId()
{
#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
    static const ::std::string typeId = "::IceMX::CollocatedMetrics";
    return typeId;
#else
    return iceC_IceMX_CollocatedMetrics_ids[2];
#endif
}

/// \cond STREAM
void
IceMX::CollocatedMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice(ice_staticId(), -1, false);
    ::Ice::StreamWriter< CollocatedMetrics, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
    ChildInvocationMetrics::_iceWriteImpl(ostr);
}

void
IceMX::CollocatedMetrics::_iceReadImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< CollocatedMetrics, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
    ChildInvocationMetrics::_iceReadImpl(istr);
}
/// \endcond

namespace
{
const ::IceInternal::DefaultValueFactoryInit< ::IceMX::CollocatedMetrics> iceC_IceMX_CollocatedMetrics_init("::IceMX::CollocatedMetrics");
}

::Ice::ValueFactoryPtr
IceMX::CollocatedMetrics::ice_factory()
{
    return ::IceInternal::factoryTable->getValueFactory(::IceMX::CollocatedMetrics::ice_staticId());
}

/// \cond INTERNAL
void
IceMX::_icePatchObjectPtr(CollocatedMetricsPtr& handle, const ::Ice::ObjectPtr& v)
{
    handle = CollocatedMetricsPtr::dynamicCast(v);
    if(v && !handle)
    {
        IceInternal::Ex::throwUOE(CollocatedMetrics::ice_staticId(), v);
    }
}
/// \endcond

IceMX::RemoteMetrics::~RemoteMetrics()
{
}

/// \cond INTERNAL
ICE_API ::Ice::Object* IceMX::upCast(RemoteMetrics* p) { return p; }

/// \endcond
::Ice::ObjectPtr
IceMX::RemoteMetrics::ice_clone() const
{
    ::Ice::Object* p = new RemoteMetrics(*this);
    return p;
}

namespace
{
const ::std::string iceC_IceMX_RemoteMetrics_ids[4] =
{
    "::Ice::Object",
    "::IceMX::ChildInvocationMetrics",
    "::IceMX::Metrics",
    "::IceMX::RemoteMetrics"
};

}

bool
IceMX::RemoteMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
{
    return ::std::binary_search(iceC_IceMX_RemoteMetrics_ids, iceC_IceMX_RemoteMetrics_ids + 4, s);
}

::std::vector< ::std::string>
IceMX::RemoteMetrics::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&iceC_IceMX_RemoteMetrics_ids[0], &iceC_IceMX_RemoteMetrics_ids[4]);
}

const ::std::string&
IceMX::RemoteMetrics::ice_id(const ::Ice::Current&) const
{
    return ice_staticId();
}

const ::std::string&
IceMX::RemoteMetrics::ice_staticId()
{
#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
    static const ::std::string typeId = "::IceMX::RemoteMetrics";
    return typeId;
#else
    return iceC_IceMX_RemoteMetrics_ids[3];
#endif
}

/// \cond STREAM
void
IceMX::RemoteMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice(ice_staticId(), -1, false);
    ::Ice::StreamWriter< RemoteMetrics, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
    ChildInvocationMetrics::_iceWriteImpl(ostr);
}

void
IceMX::RemoteMetrics::_iceReadImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< RemoteMetrics, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
    ChildInvocationMetrics::_iceReadImpl(istr);
}
/// \endcond

namespace
{
const ::IceInternal::DefaultValueFactoryInit< ::IceMX::RemoteMetrics> iceC_IceMX_RemoteMetrics_init("::IceMX::RemoteMetrics");
}

::Ice::ValueFactoryPtr
IceMX::RemoteMetrics::ice_factory()
{
    return ::IceInternal::factoryTable->getValueFactory(::IceMX::RemoteMetrics::ice_staticId());
}

/// \cond INTERNAL
void
IceMX::_icePatchObjectPtr(RemoteMetricsPtr& handle, const ::Ice::ObjectPtr& v)
{
    handle = RemoteMetricsPtr::dynamicCast(v);
    if(v && !handle)
    {
        IceInternal::Ex::throwUOE(RemoteMetrics::ice_staticId(), v);
    }
}
/// \endcond

IceMX::InvocationMetrics::~InvocationMetrics()
{
}

/// \cond INTERNAL
ICE_API ::Ice::Object* IceMX::upCast(InvocationMetrics* p) { return p; }

/// \endcond

#if defined(_MSC_VER) && (_MSC_VER >= 1900)
#   pragma warning(push)
#   pragma warning(disable:4589)
#endif
::Ice::ObjectPtr
IceMX::InvocationMetrics::ice_clone() const
{
    ::Ice::Object* p = new InvocationMetrics(*this);
    return p;
}
#if defined(_MSC_VER) && (_MSC_VER >= 1900)
#   pragma warning(pop)
#endif

namespace
{
const ::std::string iceC_IceMX_InvocationMetrics_ids[3] =
{
    "::Ice::Object",
    "::IceMX::InvocationMetrics",
    "::IceMX::Metrics"
};

}

bool
IceMX::InvocationMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
{
    return ::std::binary_search(iceC_IceMX_InvocationMetrics_ids, iceC_IceMX_InvocationMetrics_ids + 3, s);
}

::std::vector< ::std::string>
IceMX::InvocationMetrics::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&iceC_IceMX_InvocationMetrics_ids[0], &iceC_IceMX_InvocationMetrics_ids[3]);
}

const ::std::string&
IceMX::InvocationMetrics::ice_id(const ::Ice::Current&) const
{
    return ice_staticId();
}

const ::std::string&
IceMX::InvocationMetrics::ice_staticId()
{
#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
    static const ::std::string typeId = "::IceMX::InvocationMetrics";
    return typeId;
#else
    return iceC_IceMX_InvocationMetrics_ids[1];
#endif
}

void
IceMX::InvocationMetrics::_iceGcVisitMembers(::IceInternal::GCVisitor& v_)
{
    {
        for(::IceMX::MetricsMap::iterator _i0 = remotes.begin(); _i0 != remotes.end(); ++_i0)
        {
            if((*_i0))
            {
                if((::IceMX::upCast((*_i0).get())->_iceGcVisit(v_)))
                {
                    (*_i0) = 0;
                }
            }
        }
    }
    {
        for(::IceMX::MetricsMap::iterator _i0 = collocated.begin(); _i0 != collocated.end(); ++_i0)
        {
            if((*_i0))
            {
                if((::IceMX::upCast((*_i0).get())->_iceGcVisit(v_)))
                {
                    (*_i0) = 0;
                }
            }
        }
    }
}

/// \cond STREAM
void
IceMX::InvocationMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice(ice_staticId(), -1, false);
    ::Ice::StreamWriter< InvocationMetrics, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
    Metrics::_iceWriteImpl(ostr);
}

void
IceMX::InvocationMetrics::_iceReadImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< InvocationMetrics, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
    Metrics::_iceReadImpl(istr);
}
/// \endcond

namespace
{
const ::IceInternal::DefaultValueFactoryInit< ::IceMX::InvocationMetrics> iceC_IceMX_InvocationMetrics_init("::IceMX::InvocationMetrics");
}

::Ice::ValueFactoryPtr
IceMX::InvocationMetrics::ice_factory()
{
    return ::IceInternal::factoryTable->getValueFactory(::IceMX::InvocationMetrics::ice_staticId());
}

/// \cond INTERNAL
void
IceMX::_icePatchObjectPtr(InvocationMetricsPtr& handle, const ::Ice::ObjectPtr& v)
{
    handle = InvocationMetricsPtr::dynamicCast(v);
    if(v && !handle)
    {
        IceInternal::Ex::throwUOE(InvocationMetrics::ice_staticId(), v);
    }
}
/// \endcond

IceMX::ConnectionMetrics::~ConnectionMetrics()
{
}

/// \cond INTERNAL
ICE_API ::Ice::Object* IceMX::upCast(ConnectionMetrics* p) { return p; }

/// \endcond
::Ice::ObjectPtr
IceMX::ConnectionMetrics::ice_clone() const
{
    ::Ice::Object* p = new ConnectionMetrics(*this);
    return p;
}

namespace
{
const ::std::string iceC_IceMX_ConnectionMetrics_ids[3] =
{
    "::Ice::Object",
    "::IceMX::ConnectionMetrics",
    "::IceMX::Metrics"
};

}

bool
IceMX::ConnectionMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
{
    return ::std::binary_search(iceC_IceMX_ConnectionMetrics_ids, iceC_IceMX_ConnectionMetrics_ids + 3, s);
}

::std::vector< ::std::string>
IceMX::ConnectionMetrics::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&iceC_IceMX_ConnectionMetrics_ids[0], &iceC_IceMX_ConnectionMetrics_ids[3]);
}

const ::std::string&
IceMX::ConnectionMetrics::ice_id(const ::Ice::Current&) const
{
    return ice_staticId();
}

const ::std::string&
IceMX::ConnectionMetrics::ice_staticId()
{
#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
    static const ::std::string typeId = "::IceMX::ConnectionMetrics";
    return typeId;
#else
    return iceC_IceMX_ConnectionMetrics_ids[1];
#endif
}

/// \cond STREAM
void
IceMX::ConnectionMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice(ice_staticId(), -1, false);
    ::Ice::StreamWriter< ConnectionMetrics, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
    Metrics::_iceWriteImpl(ostr);
}

void
IceMX::ConnectionMetrics::_iceReadImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< ConnectionMetrics, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
    Metrics::_iceReadImpl(istr);
}
/// \endcond

namespace
{
const ::IceInternal::DefaultValueFactoryInit< ::IceMX::ConnectionMetrics> iceC_IceMX_ConnectionMetrics_init("::IceMX::ConnectionMetrics");
}

::Ice::ValueFactoryPtr
IceMX::ConnectionMetrics::ice_factory()
{
    return ::IceInternal::factoryTable->getValueFactory(::IceMX::ConnectionMetrics::ice_staticId());
}

/// \cond INTERNAL
void
IceMX::_icePatchObjectPtr(ConnectionMetricsPtr& handle, const ::Ice::ObjectPtr& v)
{
    handle = ConnectionMetricsPtr::dynamicCast(v);
    if(v && !handle)
    {
        IceInternal::Ex::throwUOE(ConnectionMetrics::ice_staticId(), v);
    }
}
/// \endcond

namespace Ice
{
}

#endif
