// **********************************************************************
//
// Copyright (c) 2003-2011 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.4.2
//
// <auto-generated>
//
// Generated from file `Admin.ice'
//
// Warning: do not edit this file.
//
// </auto-generated>
//

#ifndef __IceGrid_Admin_h__
#define __IceGrid_Admin_h__

#include <Ice/LocalObjectF.h>
#include <Ice/ProxyF.h>
#include <Ice/ObjectF.h>
#include <Ice/Exception.h>
#include <Ice/LocalObject.h>
#include <Ice/Proxy.h>
#include <Ice/Object.h>
#include <Ice/Outgoing.h>
#include <Ice/OutgoingAsync.h>
#include <Ice/Incoming.h>
#include <Ice/IncomingAsync.h>
#include <Ice/Direct.h>
#include <Ice/FactoryTableInit.h>
#include <IceUtil/ScopedArray.h>
#include <Ice/StreamF.h>
#include <Ice/Identity.h>
#include <Ice/BuiltinSequences.h>
#include <Ice/Properties.h>
#include <Ice/SliceChecksumDict.h>
#include <Glacier2/Session.h>
#include <IceGrid/Exception.h>
#include <IceGrid/Descriptor.h>
#include <Ice/UndefSysMacros.h>

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

#ifndef ICE_GRID_API
#   ifdef ICE_GRID_API_EXPORTS
#       define ICE_GRID_API ICE_DECLSPEC_EXPORT
#   else
#       define ICE_GRID_API ICE_DECLSPEC_IMPORT
#   endif
#endif

namespace IceProxy
{

namespace IceGrid
{

class Admin;
ICE_GRID_API ::IceProxy::Ice::Object* upCast(::IceProxy::IceGrid::Admin*);

class FileIterator;
ICE_GRID_API ::IceProxy::Ice::Object* upCast(::IceProxy::IceGrid::FileIterator*);

class RegistryObserver;
ICE_GRID_API ::IceProxy::Ice::Object* upCast(::IceProxy::IceGrid::RegistryObserver*);

class NodeObserver;
ICE_GRID_API ::IceProxy::Ice::Object* upCast(::IceProxy::IceGrid::NodeObserver*);

class ApplicationObserver;
ICE_GRID_API ::IceProxy::Ice::Object* upCast(::IceProxy::IceGrid::ApplicationObserver*);

class AdapterObserver;
ICE_GRID_API ::IceProxy::Ice::Object* upCast(::IceProxy::IceGrid::AdapterObserver*);

class ObjectObserver;
ICE_GRID_API ::IceProxy::Ice::Object* upCast(::IceProxy::IceGrid::ObjectObserver*);

class AdminSession;
ICE_GRID_API ::IceProxy::Ice::Object* upCast(::IceProxy::IceGrid::AdminSession*);

}

}

namespace IceGrid
{

class Admin;
bool operator==(const Admin&, const Admin&);
bool operator<(const Admin&, const Admin&);

ICE_GRID_API ::Ice::Object* upCast(::IceGrid::Admin*);

class FileIterator;
bool operator==(const FileIterator&, const FileIterator&);
bool operator<(const FileIterator&, const FileIterator&);

ICE_GRID_API ::Ice::Object* upCast(::IceGrid::FileIterator*);

class RegistryObserver;
bool operator==(const RegistryObserver&, const RegistryObserver&);
bool operator<(const RegistryObserver&, const RegistryObserver&);

ICE_GRID_API ::Ice::Object* upCast(::IceGrid::RegistryObserver*);

class NodeObserver;
bool operator==(const NodeObserver&, const NodeObserver&);
bool operator<(const NodeObserver&, const NodeObserver&);

ICE_GRID_API ::Ice::Object* upCast(::IceGrid::NodeObserver*);

class ApplicationObserver;
bool operator==(const ApplicationObserver&, const ApplicationObserver&);
bool operator<(const ApplicationObserver&, const ApplicationObserver&);

ICE_GRID_API ::Ice::Object* upCast(::IceGrid::ApplicationObserver*);

class AdapterObserver;
bool operator==(const AdapterObserver&, const AdapterObserver&);
bool operator<(const AdapterObserver&, const AdapterObserver&);

ICE_GRID_API ::Ice::Object* upCast(::IceGrid::AdapterObserver*);

class ObjectObserver;
bool operator==(const ObjectObserver&, const ObjectObserver&);
bool operator<(const ObjectObserver&, const ObjectObserver&);

ICE_GRID_API ::Ice::Object* upCast(::IceGrid::ObjectObserver*);

class AdminSession;
bool operator==(const AdminSession&, const AdminSession&);
bool operator<(const AdminSession&, const AdminSession&);

ICE_GRID_API ::Ice::Object* upCast(::IceGrid::AdminSession*);

}

namespace IceInternal
{

}

namespace IceGrid
{

typedef ::IceInternal::Handle< ::IceGrid::Admin> AdminPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::IceGrid::Admin> AdminPrx;

ICE_GRID_API void __read(::IceInternal::BasicStream*, AdminPrx&);
ICE_GRID_API void __patch__AdminPtr(void*, ::Ice::ObjectPtr&);

typedef ::IceInternal::Handle< ::IceGrid::FileIterator> FileIteratorPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::IceGrid::FileIterator> FileIteratorPrx;

ICE_GRID_API void __read(::IceInternal::BasicStream*, FileIteratorPrx&);
ICE_GRID_API void __patch__FileIteratorPtr(void*, ::Ice::ObjectPtr&);

typedef ::IceInternal::Handle< ::IceGrid::RegistryObserver> RegistryObserverPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::IceGrid::RegistryObserver> RegistryObserverPrx;

ICE_GRID_API void __read(::IceInternal::BasicStream*, RegistryObserverPrx&);
ICE_GRID_API void __patch__RegistryObserverPtr(void*, ::Ice::ObjectPtr&);

typedef ::IceInternal::Handle< ::IceGrid::NodeObserver> NodeObserverPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::IceGrid::NodeObserver> NodeObserverPrx;

ICE_GRID_API void __read(::IceInternal::BasicStream*, NodeObserverPrx&);
ICE_GRID_API void __patch__NodeObserverPtr(void*, ::Ice::ObjectPtr&);

typedef ::IceInternal::Handle< ::IceGrid::ApplicationObserver> ApplicationObserverPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::IceGrid::ApplicationObserver> ApplicationObserverPrx;

ICE_GRID_API void __read(::IceInternal::BasicStream*, ApplicationObserverPrx&);
ICE_GRID_API void __patch__ApplicationObserverPtr(void*, ::Ice::ObjectPtr&);

typedef ::IceInternal::Handle< ::IceGrid::AdapterObserver> AdapterObserverPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::IceGrid::AdapterObserver> AdapterObserverPrx;

ICE_GRID_API void __read(::IceInternal::BasicStream*, AdapterObserverPrx&);
ICE_GRID_API void __patch__AdapterObserverPtr(void*, ::Ice::ObjectPtr&);

typedef ::IceInternal::Handle< ::IceGrid::ObjectObserver> ObjectObserverPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::IceGrid::ObjectObserver> ObjectObserverPrx;

ICE_GRID_API void __read(::IceInternal::BasicStream*, ObjectObserverPrx&);
ICE_GRID_API void __patch__ObjectObserverPtr(void*, ::Ice::ObjectPtr&);

typedef ::IceInternal::Handle< ::IceGrid::AdminSession> AdminSessionPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::IceGrid::AdminSession> AdminSessionPrx;

ICE_GRID_API void __read(::IceInternal::BasicStream*, AdminSessionPrx&);
ICE_GRID_API void __patch__AdminSessionPtr(void*, ::Ice::ObjectPtr&);

}

namespace IceGrid
{

enum ServerState
{
    Inactive,
    Activating,
    ActivationTimedOut,
    Active,
    Deactivating,
    Destroying,
    Destroyed
};

ICE_GRID_API void __write(::IceInternal::BasicStream*, ServerState);
ICE_GRID_API void __read(::IceInternal::BasicStream*, ServerState&);

typedef ::std::map< ::std::string, ::Ice::ObjectPrx> StringObjectProxyDict;
ICE_GRID_API void __writeStringObjectProxyDict(::IceInternal::BasicStream*, const StringObjectProxyDict&);
ICE_GRID_API void __readStringObjectProxyDict(::IceInternal::BasicStream*, StringObjectProxyDict&);

struct ObjectInfo
{
    ::Ice::ObjectPrx proxy;
    ::std::string type;

    bool operator==(const ObjectInfo& __rhs) const
    {
        if(this == &__rhs)
        {
            return true;
        }
        if(proxy != __rhs.proxy)
        {
            return false;
        }
        if(type != __rhs.type)
        {
            return false;
        }
        return true;
    }

    bool operator<(const ObjectInfo& __rhs) const
    {
        if(this == &__rhs)
        {
            return false;
        }
        if(proxy < __rhs.proxy)
        {
            return true;
        }
        else if(__rhs.proxy < proxy)
        {
            return false;
        }
        if(type < __rhs.type)
        {
            return true;
        }
        else if(__rhs.type < type)
        {
            return false;
        }
        return false;
    }

    bool operator!=(const ObjectInfo& __rhs) const
    {
        return !operator==(__rhs);
    }
    bool operator<=(const ObjectInfo& __rhs) const
    {
        return operator<(__rhs) || operator==(__rhs);
    }
    bool operator>(const ObjectInfo& __rhs) const
    {
        return !operator<(__rhs) && !operator==(__rhs);
    }
    bool operator>=(const ObjectInfo& __rhs) const
    {
        return !operator<(__rhs);
    }

    ICE_GRID_API void __write(::IceInternal::BasicStream*) const;
    ICE_GRID_API void __read(::IceInternal::BasicStream*);
};

typedef ::std::vector< ::IceGrid::ObjectInfo> ObjectInfoSeq;
ICE_GRID_API void __writeObjectInfoSeq(::IceInternal::BasicStream*, const ::IceGrid::ObjectInfo*, const ::IceGrid::ObjectInfo*);
ICE_GRID_API void __readObjectInfoSeq(::IceInternal::BasicStream*, ObjectInfoSeq&);

struct AdapterInfo
{
    ::std::string id;
    ::Ice::ObjectPrx proxy;
    ::std::string replicaGroupId;

    bool operator==(const AdapterInfo& __rhs) const
    {
        if(this == &__rhs)
        {
            return true;
        }
        if(id != __rhs.id)
        {
            return false;
        }
        if(proxy != __rhs.proxy)
        {
            return false;
        }
        if(replicaGroupId != __rhs.replicaGroupId)
        {
            return false;
        }
        return true;
    }

    bool operator<(const AdapterInfo& __rhs) const
    {
        if(this == &__rhs)
        {
            return false;
        }
        if(id < __rhs.id)
        {
            return true;
        }
        else if(__rhs.id < id)
        {
            return false;
        }
        if(proxy < __rhs.proxy)
        {
            return true;
        }
        else if(__rhs.proxy < proxy)
        {
            return false;
        }
        if(replicaGroupId < __rhs.replicaGroupId)
        {
            return true;
        }
        else if(__rhs.replicaGroupId < replicaGroupId)
        {
            return false;
        }
        return false;
    }

    bool operator!=(const AdapterInfo& __rhs) const
    {
        return !operator==(__rhs);
    }
    bool operator<=(const AdapterInfo& __rhs) const
    {
        return operator<(__rhs) || operator==(__rhs);
    }
    bool operator>(const AdapterInfo& __rhs) const
    {
        return !operator<(__rhs) && !operator==(__rhs);
    }
    bool operator>=(const AdapterInfo& __rhs) const
    {
        return !operator<(__rhs);
    }

    ICE_GRID_API void __write(::IceInternal::BasicStream*) const;
    ICE_GRID_API void __read(::IceInternal::BasicStream*);
};

typedef ::std::vector< ::IceGrid::AdapterInfo> AdapterInfoSeq;
ICE_GRID_API void __writeAdapterInfoSeq(::IceInternal::BasicStream*, const ::IceGrid::AdapterInfo*, const ::IceGrid::AdapterInfo*);
ICE_GRID_API void __readAdapterInfoSeq(::IceInternal::BasicStream*, AdapterInfoSeq&);

struct ServerInfo
{
    ::std::string application;
    ::std::string uuid;
    ::Ice::Int revision;
    ::std::string node;
    ::IceGrid::ServerDescriptorPtr descriptor;
    ::std::string sessionId;

    bool operator==(const ServerInfo& __rhs) const
    {
        if(this == &__rhs)
        {
            return true;
        }
        if(application != __rhs.application)
        {
            return false;
        }
        if(uuid != __rhs.uuid)
        {
            return false;
        }
        if(revision != __rhs.revision)
        {
            return false;
        }
        if(node != __rhs.node)
        {
            return false;
        }
        if(descriptor != __rhs.descriptor)
        {
            return false;
        }
        if(sessionId != __rhs.sessionId)
        {
            return false;
        }
        return true;
    }

    bool operator<(const ServerInfo& __rhs) const
    {
        if(this == &__rhs)
        {
            return false;
        }
        if(application < __rhs.application)
        {
            return true;
        }
        else if(__rhs.application < application)
        {
            return false;
        }
        if(uuid < __rhs.uuid)
        {
            return true;
        }
        else if(__rhs.uuid < uuid)
        {
            return false;
        }
        if(revision < __rhs.revision)
        {
            return true;
        }
        else if(__rhs.revision < revision)
        {
            return false;
        }
        if(node < __rhs.node)
        {
            return true;
        }
        else if(__rhs.node < node)
        {
            return false;
        }
        if(descriptor < __rhs.descriptor)
        {
            return true;
        }
        else if(__rhs.descriptor < descriptor)
        {
            return false;
        }
        if(sessionId < __rhs.sessionId)
        {
            return true;
        }
        else if(__rhs.sessionId < sessionId)
        {
            return false;
        }
        return false;
    }

    bool operator!=(const ServerInfo& __rhs) const
    {
        return !operator==(__rhs);
    }
    bool operator<=(const ServerInfo& __rhs) const
    {
        return operator<(__rhs) || operator==(__rhs);
    }
    bool operator>(const ServerInfo& __rhs) const
    {
        return !operator<(__rhs) && !operator==(__rhs);
    }
    bool operator>=(const ServerInfo& __rhs) const
    {
        return !operator<(__rhs);
    }

    ICE_GRID_API void __write(::IceInternal::BasicStream*) const;
    ICE_GRID_API void __read(::IceInternal::BasicStream*);
};

struct NodeInfo
{
    ::std::string name;
    ::std::string os;
    ::std::string hostname;
    ::std::string release;
    ::std::string version;
    ::std::string machine;
    ::Ice::Int nProcessors;
    ::std::string dataDir;

    bool operator==(const NodeInfo& __rhs) const
    {
        if(this == &__rhs)
        {
            return true;
        }
        if(name != __rhs.name)
        {
            return false;
        }
        if(os != __rhs.os)
        {
            return false;
        }
        if(hostname != __rhs.hostname)
        {
            return false;
        }
        if(release != __rhs.release)
        {
            return false;
        }
        if(version != __rhs.version)
        {
            return false;
        }
        if(machine != __rhs.machine)
        {
            return false;
        }
        if(nProcessors != __rhs.nProcessors)
        {
            return false;
        }
        if(dataDir != __rhs.dataDir)
        {
            return false;
        }
        return true;
    }

    bool operator<(const NodeInfo& __rhs) const
    {
        if(this == &__rhs)
        {
            return false;
        }
        if(name < __rhs.name)
        {
            return true;
        }
        else if(__rhs.name < name)
        {
            return false;
        }
        if(os < __rhs.os)
        {
            return true;
        }
        else if(__rhs.os < os)
        {
            return false;
        }
        if(hostname < __rhs.hostname)
        {
            return true;
        }
        else if(__rhs.hostname < hostname)
        {
            return false;
        }
        if(release < __rhs.release)
        {
            return true;
        }
        else if(__rhs.release < release)
        {
            return false;
        }
        if(version < __rhs.version)
        {
            return true;
        }
        else if(__rhs.version < version)
        {
            return false;
        }
        if(machine < __rhs.machine)
        {
            return true;
        }
        else if(__rhs.machine < machine)
        {
            return false;
        }
        if(nProcessors < __rhs.nProcessors)
        {
            return true;
        }
        else if(__rhs.nProcessors < nProcessors)
        {
            return false;
        }
        if(dataDir < __rhs.dataDir)
        {
            return true;
        }
        else if(__rhs.dataDir < dataDir)
        {
            return false;
        }
        return false;
    }

    bool operator!=(const NodeInfo& __rhs) const
    {
        return !operator==(__rhs);
    }
    bool operator<=(const NodeInfo& __rhs) const
    {
        return operator<(__rhs) || operator==(__rhs);
    }
    bool operator>(const NodeInfo& __rhs) const
    {
        return !operator<(__rhs) && !operator==(__rhs);
    }
    bool operator>=(const NodeInfo& __rhs) const
    {
        return !operator<(__rhs);
    }

    ICE_GRID_API void __write(::IceInternal::BasicStream*) const;
    ICE_GRID_API void __read(::IceInternal::BasicStream*);
};

struct RegistryInfo
{
    ::std::string name;
    ::std::string hostname;

    bool operator==(const RegistryInfo& __rhs) const
    {
        if(this == &__rhs)
        {
            return true;
        }
        if(name != __rhs.name)
        {
            return false;
        }
        if(hostname != __rhs.hostname)
        {
            return false;
        }
        return true;
    }

    bool operator<(const RegistryInfo& __rhs) const
    {
        if(this == &__rhs)
        {
            return false;
        }
        if(name < __rhs.name)
        {
            return true;
        }
        else if(__rhs.name < name)
        {
            return false;
        }
        if(hostname < __rhs.hostname)
        {
            return true;
        }
        else if(__rhs.hostname < hostname)
        {
            return false;
        }
        return false;
    }

    bool operator!=(const RegistryInfo& __rhs) const
    {
        return !operator==(__rhs);
    }
    bool operator<=(const RegistryInfo& __rhs) const
    {
        return operator<(__rhs) || operator==(__rhs);
    }
    bool operator>(const RegistryInfo& __rhs) const
    {
        return !operator<(__rhs) && !operator==(__rhs);
    }
    bool operator>=(const RegistryInfo& __rhs) const
    {
        return !operator<(__rhs);
    }

    ICE_GRID_API void __write(::IceInternal::BasicStream*) const;
    ICE_GRID_API void __read(::IceInternal::BasicStream*);
};

typedef ::std::vector< ::IceGrid::RegistryInfo> RegistryInfoSeq;
ICE_GRID_API void __writeRegistryInfoSeq(::IceInternal::BasicStream*, const ::IceGrid::RegistryInfo*, const ::IceGrid::RegistryInfo*);
ICE_GRID_API void __readRegistryInfoSeq(::IceInternal::BasicStream*, RegistryInfoSeq&);

struct LoadInfo
{
    ::Ice::Float avg1;
    ::Ice::Float avg5;
    ::Ice::Float avg15;

    bool operator==(const LoadInfo& __rhs) const
    {
        if(this == &__rhs)
        {
            return true;
        }
        if(avg1 != __rhs.avg1)
        {
            return false;
        }
        if(avg5 != __rhs.avg5)
        {
            return false;
        }
        if(avg15 != __rhs.avg15)
        {
            return false;
        }
        return true;
    }

    bool operator<(const LoadInfo& __rhs) const
    {
        if(this == &__rhs)
        {
            return false;
        }
        if(avg1 < __rhs.avg1)
        {
            return true;
        }
        else if(__rhs.avg1 < avg1)
        {
            return false;
        }
        if(avg5 < __rhs.avg5)
        {
            return true;
        }
        else if(__rhs.avg5 < avg5)
        {
            return false;
        }
        if(avg15 < __rhs.avg15)
        {
            return true;
        }
        else if(__rhs.avg15 < avg15)
        {
            return false;
        }
        return false;
    }

    bool operator!=(const LoadInfo& __rhs) const
    {
        return !operator==(__rhs);
    }
    bool operator<=(const LoadInfo& __rhs) const
    {
        return operator<(__rhs) || operator==(__rhs);
    }
    bool operator>(const LoadInfo& __rhs) const
    {
        return !operator<(__rhs) && !operator==(__rhs);
    }
    bool operator>=(const LoadInfo& __rhs) const
    {
        return !operator<(__rhs);
    }

    ICE_GRID_API void __write(::IceInternal::BasicStream*) const;
    ICE_GRID_API void __read(::IceInternal::BasicStream*);
};

struct ApplicationInfo
{
    ::std::string uuid;
    ::Ice::Long createTime;
    ::std::string createUser;
    ::Ice::Long updateTime;
    ::std::string updateUser;
    ::Ice::Int revision;
    ::IceGrid::ApplicationDescriptor descriptor;

    bool operator==(const ApplicationInfo& __rhs) const
    {
        if(this == &__rhs)
        {
            return true;
        }
        if(uuid != __rhs.uuid)
        {
            return false;
        }
        if(createTime != __rhs.createTime)
        {
            return false;
        }
        if(createUser != __rhs.createUser)
        {
            return false;
        }
        if(updateTime != __rhs.updateTime)
        {
            return false;
        }
        if(updateUser != __rhs.updateUser)
        {
            return false;
        }
        if(revision != __rhs.revision)
        {
            return false;
        }
        if(descriptor != __rhs.descriptor)
        {
            return false;
        }
        return true;
    }

    bool operator<(const ApplicationInfo& __rhs) const
    {
        if(this == &__rhs)
        {
            return false;
        }
        if(uuid < __rhs.uuid)
        {
            return true;
        }
        else if(__rhs.uuid < uuid)
        {
            return false;
        }
        if(createTime < __rhs.createTime)
        {
            return true;
        }
        else if(__rhs.createTime < createTime)
        {
            return false;
        }
        if(createUser < __rhs.createUser)
        {
            return true;
        }
        else if(__rhs.createUser < createUser)
        {
            return false;
        }
        if(updateTime < __rhs.updateTime)
        {
            return true;
        }
        else if(__rhs.updateTime < updateTime)
        {
            return false;
        }
        if(updateUser < __rhs.updateUser)
        {
            return true;
        }
        else if(__rhs.updateUser < updateUser)
        {
            return false;
        }
        if(revision < __rhs.revision)
        {
            return true;
        }
        else if(__rhs.revision < revision)
        {
            return false;
        }
        if(descriptor < __rhs.descriptor)
        {
            return true;
        }
        else if(__rhs.descriptor < descriptor)
        {
            return false;
        }
        return false;
    }

    bool operator!=(const ApplicationInfo& __rhs) const
    {
        return !operator==(__rhs);
    }
    bool operator<=(const ApplicationInfo& __rhs) const
    {
        return operator<(__rhs) || operator==(__rhs);
    }
    bool operator>(const ApplicationInfo& __rhs) const
    {
        return !operator<(__rhs) && !operator==(__rhs);
    }
    bool operator>=(const ApplicationInfo& __rhs) const
    {
        return !operator<(__rhs);
    }

    ICE_GRID_API void __write(::IceInternal::BasicStream*) const;
    ICE_GRID_API void __read(::IceInternal::BasicStream*);
};

typedef ::std::vector< ::IceGrid::ApplicationInfo> ApplicationInfoSeq;
ICE_GRID_API void __writeApplicationInfoSeq(::IceInternal::BasicStream*, const ::IceGrid::ApplicationInfo*, const ::IceGrid::ApplicationInfo*);
ICE_GRID_API void __readApplicationInfoSeq(::IceInternal::BasicStream*, ApplicationInfoSeq&);

struct ApplicationUpdateInfo
{
    ::Ice::Long updateTime;
    ::std::string updateUser;
    ::Ice::Int revision;
    ::IceGrid::ApplicationUpdateDescriptor descriptor;

    bool operator==(const ApplicationUpdateInfo& __rhs) const
    {
        if(this == &__rhs)
        {
            return true;
        }
        if(updateTime != __rhs.updateTime)
        {
            return false;
        }
        if(updateUser != __rhs.updateUser)
        {
            return false;
        }
        if(revision != __rhs.revision)
        {
            return false;
        }
        if(descriptor != __rhs.descriptor)
        {
            return false;
        }
        return true;
    }

    bool operator<(const ApplicationUpdateInfo& __rhs) const
    {
        if(this == &__rhs)
        {
            return false;
        }
        if(updateTime < __rhs.updateTime)
        {
            return true;
        }
        else if(__rhs.updateTime < updateTime)
        {
            return false;
        }
        if(updateUser < __rhs.updateUser)
        {
            return true;
        }
        else if(__rhs.updateUser < updateUser)
        {
            return false;
        }
        if(revision < __rhs.revision)
        {
            return true;
        }
        else if(__rhs.revision < revision)
        {
            return false;
        }
        if(descriptor < __rhs.descriptor)
        {
            return true;
        }
        else if(__rhs.descriptor < descriptor)
        {
            return false;
        }
        return false;
    }

    bool operator!=(const ApplicationUpdateInfo& __rhs) const
    {
        return !operator==(__rhs);
    }
    bool operator<=(const ApplicationUpdateInfo& __rhs) const
    {
        return operator<(__rhs) || operator==(__rhs);
    }
    bool operator>(const ApplicationUpdateInfo& __rhs) const
    {
        return !operator<(__rhs) && !operator==(__rhs);
    }
    bool operator>=(const ApplicationUpdateInfo& __rhs) const
    {
        return !operator<(__rhs);
    }

    ICE_GRID_API void __write(::IceInternal::BasicStream*) const;
    ICE_GRID_API void __read(::IceInternal::BasicStream*);
};

}

namespace IceGrid
{

class ICE_GRID_API AMI_Admin_addApplication : public ::Ice::AMICallbackBase
{
public:

    virtual void ice_response() = 0;

    void __response()
    {
        ice_response();
    }
    void __exception(const ::Ice::Exception& ex)
    {
        ice_exception(ex);
    }
    void __sent(bool sentSynchronously)
    {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        AMICallbackBase::__sent(sentSynchronously);
#else
        ::Ice::AMICallbackBase::__sent(sentSynchronously);
#endif
    }
};

typedef ::IceUtil::Handle< ::IceGrid::AMI_Admin_addApplication> AMI_Admin_addApplicationPtr;

class ICE_GRID_API AMI_Admin_syncApplication : public ::Ice::AMICallbackBase
{
public:

    virtual void ice_response() = 0;

    void __response()
    {
        ice_response();
    }
    void __exception(const ::Ice::Exception& ex)
    {
        ice_exception(ex);
    }
    void __sent(bool sentSynchronously)
    {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        AMICallbackBase::__sent(sentSynchronously);
#else
        ::Ice::AMICallbackBase::__sent(sentSynchronously);
#endif
    }
};

typedef ::IceUtil::Handle< ::IceGrid::AMI_Admin_syncApplication> AMI_Admin_syncApplicationPtr;

class ICE_GRID_API AMI_Admin_updateApplication : public ::Ice::AMICallbackBase
{
public:

    virtual void ice_response() = 0;

    void __response()
    {
        ice_response();
    }
    void __exception(const ::Ice::Exception& ex)
    {
        ice_exception(ex);
    }
    void __sent(bool sentSynchronously)
    {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        AMICallbackBase::__sent(sentSynchronously);
#else
        ::Ice::AMICallbackBase::__sent(sentSynchronously);
#endif
    }
};

typedef ::IceUtil::Handle< ::IceGrid::AMI_Admin_updateApplication> AMI_Admin_updateApplicationPtr;

class ICE_GRID_API AMI_Admin_removeApplication : public ::Ice::AMICallbackBase
{
public:

    virtual void ice_response() = 0;

    void __response()
    {
        ice_response();
    }
    void __exception(const ::Ice::Exception& ex)
    {
        ice_exception(ex);
    }
    void __sent(bool sentSynchronously)
    {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        AMICallbackBase::__sent(sentSynchronously);
#else
        ::Ice::AMICallbackBase::__sent(sentSynchronously);
#endif
    }
};

typedef ::IceUtil::Handle< ::IceGrid::AMI_Admin_removeApplication> AMI_Admin_removeApplicationPtr;

class ICE_GRID_API AMI_Admin_patchApplication : public ::Ice::AMICallbackBase
{
public:

    virtual void ice_response() = 0;

    void __response()
    {
        ice_response();
    }
    void __exception(const ::Ice::Exception& ex)
    {
        ice_exception(ex);
    }
    void __sent(bool sentSynchronously)
    {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        AMICallbackBase::__sent(sentSynchronously);
#else
        ::Ice::AMICallbackBase::__sent(sentSynchronously);
#endif
    }
};

typedef ::IceUtil::Handle< ::IceGrid::AMI_Admin_patchApplication> AMI_Admin_patchApplicationPtr;

class ICE_GRID_API AMD_Admin_patchApplication : virtual public ::Ice::AMDCallback
{
public:

    virtual void ice_response() = 0;
};

typedef ::IceUtil::Handle< ::IceGrid::AMD_Admin_patchApplication> AMD_Admin_patchApplicationPtr;

class ICE_GRID_API AMI_Admin_enableServer : public ::Ice::AMICallbackBase
{
public:

    virtual void ice_response() = 0;

    void __response()
    {
        ice_response();
    }
    void __exception(const ::Ice::Exception& ex)
    {
        ice_exception(ex);
    }
    void __sent(bool sentSynchronously)
    {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        AMICallbackBase::__sent(sentSynchronously);
#else
        ::Ice::AMICallbackBase::__sent(sentSynchronously);
#endif
    }
};

typedef ::IceUtil::Handle< ::IceGrid::AMI_Admin_enableServer> AMI_Admin_enableServerPtr;

class ICE_GRID_API AMI_Admin_startServer : public ::Ice::AMICallbackBase
{
public:

    virtual void ice_response() = 0;

    void __response()
    {
        ice_response();
    }
    void __exception(const ::Ice::Exception& ex)
    {
        ice_exception(ex);
    }
    void __sent(bool sentSynchronously)
    {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        AMICallbackBase::__sent(sentSynchronously);
#else
        ::Ice::AMICallbackBase::__sent(sentSynchronously);
#endif
    }
};

typedef ::IceUtil::Handle< ::IceGrid::AMI_Admin_startServer> AMI_Admin_startServerPtr;

class ICE_GRID_API AMD_Admin_startServer : virtual public ::Ice::AMDCallback
{
public:

    virtual void ice_response() = 0;
};

typedef ::IceUtil::Handle< ::IceGrid::AMD_Admin_startServer> AMD_Admin_startServerPtr;

class ICE_GRID_API AMI_Admin_stopServer : public ::Ice::AMICallbackBase
{
public:

    virtual void ice_response() = 0;

    void __response()
    {
        ice_response();
    }
    void __exception(const ::Ice::Exception& ex)
    {
        ice_exception(ex);
    }
    void __sent(bool sentSynchronously)
    {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        AMICallbackBase::__sent(sentSynchronously);
#else
        ::Ice::AMICallbackBase::__sent(sentSynchronously);
#endif
    }
};

typedef ::IceUtil::Handle< ::IceGrid::AMI_Admin_stopServer> AMI_Admin_stopServerPtr;

class ICE_GRID_API AMD_Admin_stopServer : virtual public ::Ice::AMDCallback
{
public:

    virtual void ice_response() = 0;
};

typedef ::IceUtil::Handle< ::IceGrid::AMD_Admin_stopServer> AMD_Admin_stopServerPtr;

class ICE_GRID_API AMI_Admin_patchServer : public ::Ice::AMICallbackBase
{
public:

    virtual void ice_response() = 0;

    void __response()
    {
        ice_response();
    }
    void __exception(const ::Ice::Exception& ex)
    {
        ice_exception(ex);
    }
    void __sent(bool sentSynchronously)
    {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        AMICallbackBase::__sent(sentSynchronously);
#else
        ::Ice::AMICallbackBase::__sent(sentSynchronously);
#endif
    }
};

typedef ::IceUtil::Handle< ::IceGrid::AMI_Admin_patchServer> AMI_Admin_patchServerPtr;

class ICE_GRID_API AMD_Admin_patchServer : virtual public ::Ice::AMDCallback
{
public:

    virtual void ice_response() = 0;
};

typedef ::IceUtil::Handle< ::IceGrid::AMD_Admin_patchServer> AMD_Admin_patchServerPtr;

class ICE_GRID_API AMI_Admin_sendSignal : public ::Ice::AMICallbackBase
{
public:

    virtual void ice_response() = 0;

    void __response()
    {
        ice_response();
    }
    void __exception(const ::Ice::Exception& ex)
    {
        ice_exception(ex);
    }
    void __sent(bool sentSynchronously)
    {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        AMICallbackBase::__sent(sentSynchronously);
#else
        ::Ice::AMICallbackBase::__sent(sentSynchronously);
#endif
    }
};

typedef ::IceUtil::Handle< ::IceGrid::AMI_Admin_sendSignal> AMI_Admin_sendSignalPtr;

class ICE_GRID_API AMI_Admin_writeMessage : public ::Ice::AMICallbackBase
{
public:

    virtual void ice_response() = 0;

    void __response()
    {
        ice_response();
    }
    void __exception(const ::Ice::Exception& ex)
    {
        ice_exception(ex);
    }
    void __sent(bool sentSynchronously)
    {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        AMICallbackBase::__sent(sentSynchronously);
#else
        ::Ice::AMICallbackBase::__sent(sentSynchronously);
#endif
    }
};

typedef ::IceUtil::Handle< ::IceGrid::AMI_Admin_writeMessage> AMI_Admin_writeMessagePtr;

class ICE_GRID_API AMI_Admin_removeAdapter : public ::Ice::AMICallbackBase
{
public:

    virtual void ice_response() = 0;

    void __response()
    {
        ice_response();
    }
    void __exception(const ::Ice::Exception& ex)
    {
        ice_exception(ex);
    }
    void __sent(bool sentSynchronously)
    {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        AMICallbackBase::__sent(sentSynchronously);
#else
        ::Ice::AMICallbackBase::__sent(sentSynchronously);
#endif
    }
};

typedef ::IceUtil::Handle< ::IceGrid::AMI_Admin_removeAdapter> AMI_Admin_removeAdapterPtr;

class ICE_GRID_API AMI_Admin_addObject : public ::Ice::AMICallbackBase
{
public:

    virtual void ice_response() = 0;

    void __response()
    {
        ice_response();
    }
    void __exception(const ::Ice::Exception& ex)
    {
        ice_exception(ex);
    }
    void __sent(bool sentSynchronously)
    {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        AMICallbackBase::__sent(sentSynchronously);
#else
        ::Ice::AMICallbackBase::__sent(sentSynchronously);
#endif
    }
};

typedef ::IceUtil::Handle< ::IceGrid::AMI_Admin_addObject> AMI_Admin_addObjectPtr;

class ICE_GRID_API AMI_Admin_addObjectWithType : public ::Ice::AMICallbackBase
{
public:

    virtual void ice_response() = 0;

    void __response()
    {
        ice_response();
    }
    void __exception(const ::Ice::Exception& ex)
    {
        ice_exception(ex);
    }
    void __sent(bool sentSynchronously)
    {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        AMICallbackBase::__sent(sentSynchronously);
#else
        ::Ice::AMICallbackBase::__sent(sentSynchronously);
#endif
    }
};

typedef ::IceUtil::Handle< ::IceGrid::AMI_Admin_addObjectWithType> AMI_Admin_addObjectWithTypePtr;

class ICE_GRID_API AMI_Admin_removeObject : public ::Ice::AMICallbackBase
{
public:

    virtual void ice_response() = 0;

    void __response()
    {
        ice_response();
    }
    void __exception(const ::Ice::Exception& ex)
    {
        ice_exception(ex);
    }
    void __sent(bool sentSynchronously)
    {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        AMICallbackBase::__sent(sentSynchronously);
#else
        ::Ice::AMICallbackBase::__sent(sentSynchronously);
#endif
    }
};

typedef ::IceUtil::Handle< ::IceGrid::AMI_Admin_removeObject> AMI_Admin_removeObjectPtr;

class ICE_GRID_API AMI_Admin_getNodeLoad : public ::Ice::AMICallbackBase
{
public:

    virtual void ice_response(const ::IceGrid::LoadInfo&) = 0;

    void __response(const ::IceGrid::LoadInfo& __ret)
    {
        ice_response(__ret);
    }
    void __exception(const ::Ice::Exception& ex)
    {
        ice_exception(ex);
    }
    void __sent(bool sentSynchronously)
    {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        AMICallbackBase::__sent(sentSynchronously);
#else
        ::Ice::AMICallbackBase::__sent(sentSynchronously);
#endif
    }
};

typedef ::IceUtil::Handle< ::IceGrid::AMI_Admin_getNodeLoad> AMI_Admin_getNodeLoadPtr;

class ICE_GRID_API AMI_Admin_shutdownNode : public ::Ice::AMICallbackBase
{
public:

    virtual void ice_response() = 0;

    void __response()
    {
        ice_response();
    }
    void __exception(const ::Ice::Exception& ex)
    {
        ice_exception(ex);
    }
    void __sent(bool sentSynchronously)
    {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        AMICallbackBase::__sent(sentSynchronously);
#else
        ::Ice::AMICallbackBase::__sent(sentSynchronously);
#endif
    }
};

typedef ::IceUtil::Handle< ::IceGrid::AMI_Admin_shutdownNode> AMI_Admin_shutdownNodePtr;

class ICE_GRID_API AMI_Admin_shutdownRegistry : public ::Ice::AMICallbackBase
{
public:

    virtual void ice_response() = 0;

    void __response()
    {
        ice_response();
    }
    void __exception(const ::Ice::Exception& ex)
    {
        ice_exception(ex);
    }
    void __sent(bool sentSynchronously)
    {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        AMICallbackBase::__sent(sentSynchronously);
#else
        ::Ice::AMICallbackBase::__sent(sentSynchronously);
#endif
    }
};

typedef ::IceUtil::Handle< ::IceGrid::AMI_Admin_shutdownRegistry> AMI_Admin_shutdownRegistryPtr;

}

namespace IceAsync
{

namespace IceGrid
{

class ICE_GRID_API AMD_Admin_patchApplication : public ::IceGrid::AMD_Admin_patchApplication, public ::IceInternal::IncomingAsync
{
public:

    AMD_Admin_patchApplication(::IceInternal::Incoming&);

    virtual void ice_response();
    virtual void ice_exception(const ::std::exception&);
#if defined(__BCPLUSPLUS__)
    // COMPILERFIX: Avoid compiler warnings with C++Builder 2010
    virtual void ice_exception()
    {
        ::IceInternal::IncomingAsync::ice_exception();
    }
#endif
};

class ICE_GRID_API AMD_Admin_startServer : public ::IceGrid::AMD_Admin_startServer, public ::IceInternal::IncomingAsync
{
public:

    AMD_Admin_startServer(::IceInternal::Incoming&);

    virtual void ice_response();
    virtual void ice_exception(const ::std::exception&);
#if defined(__BCPLUSPLUS__)
    // COMPILERFIX: Avoid compiler warnings with C++Builder 2010
    virtual void ice_exception()
    {
        ::IceInternal::IncomingAsync::ice_exception();
    }
#endif
};

class ICE_GRID_API AMD_Admin_stopServer : public ::IceGrid::AMD_Admin_stopServer, public ::IceInternal::IncomingAsync
{
public:

    AMD_Admin_stopServer(::IceInternal::Incoming&);

    virtual void ice_response();
    virtual void ice_exception(const ::std::exception&);
#if defined(__BCPLUSPLUS__)
    // COMPILERFIX: Avoid compiler warnings with C++Builder 2010
    virtual void ice_exception()
    {
        ::IceInternal::IncomingAsync::ice_exception();
    }
#endif
};

class ICE_GRID_API AMD_Admin_patchServer : public ::IceGrid::AMD_Admin_patchServer, public ::IceInternal::IncomingAsync
{
public:

    AMD_Admin_patchServer(::IceInternal::Incoming&);

    virtual void ice_response();
    virtual void ice_exception(const ::std::exception&);
#if defined(__BCPLUSPLUS__)
    // COMPILERFIX: Avoid compiler warnings with C++Builder 2010
    virtual void ice_exception()
    {
        ::IceInternal::IncomingAsync::ice_exception();
    }
#endif
};

}

}

namespace IceGrid
{

class Callback_Admin_addApplication_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_addApplication_Base> Callback_Admin_addApplicationPtr;

class Callback_Admin_syncApplication_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_syncApplication_Base> Callback_Admin_syncApplicationPtr;

class Callback_Admin_updateApplication_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_updateApplication_Base> Callback_Admin_updateApplicationPtr;

class Callback_Admin_removeApplication_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_removeApplication_Base> Callback_Admin_removeApplicationPtr;

class Callback_Admin_instantiateServer_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_instantiateServer_Base> Callback_Admin_instantiateServerPtr;

class Callback_Admin_patchApplication_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_patchApplication_Base> Callback_Admin_patchApplicationPtr;

class Callback_Admin_getApplicationInfo_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_getApplicationInfo_Base> Callback_Admin_getApplicationInfoPtr;

class Callback_Admin_getDefaultApplicationDescriptor_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_getDefaultApplicationDescriptor_Base> Callback_Admin_getDefaultApplicationDescriptorPtr;

class Callback_Admin_getAllApplicationNames_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_getAllApplicationNames_Base> Callback_Admin_getAllApplicationNamesPtr;

class Callback_Admin_getServerInfo_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_getServerInfo_Base> Callback_Admin_getServerInfoPtr;

class Callback_Admin_getServerState_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_getServerState_Base> Callback_Admin_getServerStatePtr;

class Callback_Admin_getServerPid_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_getServerPid_Base> Callback_Admin_getServerPidPtr;

class Callback_Admin_getServerAdminCategory_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_getServerAdminCategory_Base> Callback_Admin_getServerAdminCategoryPtr;

class Callback_Admin_getServerAdmin_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_getServerAdmin_Base> Callback_Admin_getServerAdminPtr;

class Callback_Admin_enableServer_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_enableServer_Base> Callback_Admin_enableServerPtr;

class Callback_Admin_isServerEnabled_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_isServerEnabled_Base> Callback_Admin_isServerEnabledPtr;

class Callback_Admin_startServer_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_startServer_Base> Callback_Admin_startServerPtr;

class Callback_Admin_stopServer_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_stopServer_Base> Callback_Admin_stopServerPtr;

class Callback_Admin_patchServer_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_patchServer_Base> Callback_Admin_patchServerPtr;

class Callback_Admin_sendSignal_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_sendSignal_Base> Callback_Admin_sendSignalPtr;

class Callback_Admin_writeMessage_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_writeMessage_Base> Callback_Admin_writeMessagePtr;

class Callback_Admin_getAllServerIds_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_getAllServerIds_Base> Callback_Admin_getAllServerIdsPtr;

class Callback_Admin_getAdapterInfo_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_getAdapterInfo_Base> Callback_Admin_getAdapterInfoPtr;

class Callback_Admin_removeAdapter_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_removeAdapter_Base> Callback_Admin_removeAdapterPtr;

class Callback_Admin_getAllAdapterIds_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_getAllAdapterIds_Base> Callback_Admin_getAllAdapterIdsPtr;

class Callback_Admin_addObject_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_addObject_Base> Callback_Admin_addObjectPtr;

class Callback_Admin_updateObject_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_updateObject_Base> Callback_Admin_updateObjectPtr;

class Callback_Admin_addObjectWithType_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_addObjectWithType_Base> Callback_Admin_addObjectWithTypePtr;

class Callback_Admin_removeObject_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_removeObject_Base> Callback_Admin_removeObjectPtr;

class Callback_Admin_getObjectInfo_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_getObjectInfo_Base> Callback_Admin_getObjectInfoPtr;

class Callback_Admin_getObjectInfosByType_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_getObjectInfosByType_Base> Callback_Admin_getObjectInfosByTypePtr;

class Callback_Admin_getAllObjectInfos_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_getAllObjectInfos_Base> Callback_Admin_getAllObjectInfosPtr;

class Callback_Admin_pingNode_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_pingNode_Base> Callback_Admin_pingNodePtr;

class Callback_Admin_getNodeLoad_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_getNodeLoad_Base> Callback_Admin_getNodeLoadPtr;

class Callback_Admin_getNodeInfo_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_getNodeInfo_Base> Callback_Admin_getNodeInfoPtr;

class Callback_Admin_getNodeProcessorSocketCount_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_getNodeProcessorSocketCount_Base> Callback_Admin_getNodeProcessorSocketCountPtr;

class Callback_Admin_shutdownNode_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_shutdownNode_Base> Callback_Admin_shutdownNodePtr;

class Callback_Admin_getNodeHostname_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_getNodeHostname_Base> Callback_Admin_getNodeHostnamePtr;

class Callback_Admin_getAllNodeNames_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_getAllNodeNames_Base> Callback_Admin_getAllNodeNamesPtr;

class Callback_Admin_pingRegistry_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_pingRegistry_Base> Callback_Admin_pingRegistryPtr;

class Callback_Admin_getRegistryInfo_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_getRegistryInfo_Base> Callback_Admin_getRegistryInfoPtr;

class Callback_Admin_shutdownRegistry_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_shutdownRegistry_Base> Callback_Admin_shutdownRegistryPtr;

class Callback_Admin_getAllRegistryNames_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_getAllRegistryNames_Base> Callback_Admin_getAllRegistryNamesPtr;

class Callback_Admin_shutdown_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_shutdown_Base> Callback_Admin_shutdownPtr;

class Callback_Admin_getSliceChecksums_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Admin_getSliceChecksums_Base> Callback_Admin_getSliceChecksumsPtr;

class Callback_FileIterator_read_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_FileIterator_read_Base> Callback_FileIterator_readPtr;

class Callback_FileIterator_destroy_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_FileIterator_destroy_Base> Callback_FileIterator_destroyPtr;

class Callback_AdminSession_keepAlive_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_AdminSession_keepAlive_Base> Callback_AdminSession_keepAlivePtr;

class Callback_AdminSession_getAdmin_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_AdminSession_getAdmin_Base> Callback_AdminSession_getAdminPtr;

class Callback_AdminSession_getAdminCallbackTemplate_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_AdminSession_getAdminCallbackTemplate_Base> Callback_AdminSession_getAdminCallbackTemplatePtr;

class Callback_AdminSession_setObservers_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_AdminSession_setObservers_Base> Callback_AdminSession_setObserversPtr;

class Callback_AdminSession_setObserversByIdentity_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_AdminSession_setObserversByIdentity_Base> Callback_AdminSession_setObserversByIdentityPtr;

class Callback_AdminSession_startUpdate_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_AdminSession_startUpdate_Base> Callback_AdminSession_startUpdatePtr;

class Callback_AdminSession_finishUpdate_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_AdminSession_finishUpdate_Base> Callback_AdminSession_finishUpdatePtr;

class Callback_AdminSession_getReplicaName_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_AdminSession_getReplicaName_Base> Callback_AdminSession_getReplicaNamePtr;

class Callback_AdminSession_openServerLog_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_AdminSession_openServerLog_Base> Callback_AdminSession_openServerLogPtr;

class Callback_AdminSession_openServerStdErr_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_AdminSession_openServerStdErr_Base> Callback_AdminSession_openServerStdErrPtr;

class Callback_AdminSession_openServerStdOut_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_AdminSession_openServerStdOut_Base> Callback_AdminSession_openServerStdOutPtr;

class Callback_AdminSession_openNodeStdErr_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_AdminSession_openNodeStdErr_Base> Callback_AdminSession_openNodeStdErrPtr;

class Callback_AdminSession_openNodeStdOut_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_AdminSession_openNodeStdOut_Base> Callback_AdminSession_openNodeStdOutPtr;

class Callback_AdminSession_openRegistryStdErr_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_AdminSession_openRegistryStdErr_Base> Callback_AdminSession_openRegistryStdErrPtr;

class Callback_AdminSession_openRegistryStdOut_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_AdminSession_openRegistryStdOut_Base> Callback_AdminSession_openRegistryStdOutPtr;

}

namespace IceProxy
{

namespace IceGrid
{

class Admin : virtual public ::IceProxy::Ice::Object
{
public:

    void addApplication(const ::IceGrid::ApplicationDescriptor& descriptor)
    {
        addApplication(descriptor, 0);
    }
    void addApplication(const ::IceGrid::ApplicationDescriptor& descriptor, const ::Ice::Context& __ctx)
    {
        addApplication(descriptor, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_addApplication(const ::IceGrid::ApplicationDescriptor& descriptor)
    {
        return begin_addApplication(descriptor, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_addApplication(const ::IceGrid::ApplicationDescriptor& descriptor, const ::Ice::Context& __ctx)
    {
        return begin_addApplication(descriptor, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_addApplication(const ::IceGrid::ApplicationDescriptor& descriptor, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_addApplication(descriptor, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_addApplication(const ::IceGrid::ApplicationDescriptor& descriptor, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_addApplication(descriptor, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_addApplication(const ::IceGrid::ApplicationDescriptor& descriptor, const ::IceGrid::Callback_Admin_addApplicationPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_addApplication(descriptor, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_addApplication(const ::IceGrid::ApplicationDescriptor& descriptor, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_addApplicationPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_addApplication(descriptor, &__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_addApplication(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void addApplication(const ::IceGrid::ApplicationDescriptor&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_addApplication(const ::IceGrid::ApplicationDescriptor&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    ICE_GRID_API bool addApplication_async(const ::IceGrid::AMI_Admin_addApplicationPtr&, const ::IceGrid::ApplicationDescriptor&);
    ICE_GRID_API bool addApplication_async(const ::IceGrid::AMI_Admin_addApplicationPtr&, const ::IceGrid::ApplicationDescriptor&, const ::Ice::Context&);

    void syncApplication(const ::IceGrid::ApplicationDescriptor& descriptor)
    {
        syncApplication(descriptor, 0);
    }
    void syncApplication(const ::IceGrid::ApplicationDescriptor& descriptor, const ::Ice::Context& __ctx)
    {
        syncApplication(descriptor, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_syncApplication(const ::IceGrid::ApplicationDescriptor& descriptor)
    {
        return begin_syncApplication(descriptor, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_syncApplication(const ::IceGrid::ApplicationDescriptor& descriptor, const ::Ice::Context& __ctx)
    {
        return begin_syncApplication(descriptor, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_syncApplication(const ::IceGrid::ApplicationDescriptor& descriptor, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_syncApplication(descriptor, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_syncApplication(const ::IceGrid::ApplicationDescriptor& descriptor, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_syncApplication(descriptor, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_syncApplication(const ::IceGrid::ApplicationDescriptor& descriptor, const ::IceGrid::Callback_Admin_syncApplicationPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_syncApplication(descriptor, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_syncApplication(const ::IceGrid::ApplicationDescriptor& descriptor, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_syncApplicationPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_syncApplication(descriptor, &__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_syncApplication(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void syncApplication(const ::IceGrid::ApplicationDescriptor&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_syncApplication(const ::IceGrid::ApplicationDescriptor&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    ICE_GRID_API bool syncApplication_async(const ::IceGrid::AMI_Admin_syncApplicationPtr&, const ::IceGrid::ApplicationDescriptor&);
    ICE_GRID_API bool syncApplication_async(const ::IceGrid::AMI_Admin_syncApplicationPtr&, const ::IceGrid::ApplicationDescriptor&, const ::Ice::Context&);

    void updateApplication(const ::IceGrid::ApplicationUpdateDescriptor& descriptor)
    {
        updateApplication(descriptor, 0);
    }
    void updateApplication(const ::IceGrid::ApplicationUpdateDescriptor& descriptor, const ::Ice::Context& __ctx)
    {
        updateApplication(descriptor, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_updateApplication(const ::IceGrid::ApplicationUpdateDescriptor& descriptor)
    {
        return begin_updateApplication(descriptor, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_updateApplication(const ::IceGrid::ApplicationUpdateDescriptor& descriptor, const ::Ice::Context& __ctx)
    {
        return begin_updateApplication(descriptor, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_updateApplication(const ::IceGrid::ApplicationUpdateDescriptor& descriptor, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_updateApplication(descriptor, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_updateApplication(const ::IceGrid::ApplicationUpdateDescriptor& descriptor, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_updateApplication(descriptor, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_updateApplication(const ::IceGrid::ApplicationUpdateDescriptor& descriptor, const ::IceGrid::Callback_Admin_updateApplicationPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_updateApplication(descriptor, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_updateApplication(const ::IceGrid::ApplicationUpdateDescriptor& descriptor, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_updateApplicationPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_updateApplication(descriptor, &__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_updateApplication(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void updateApplication(const ::IceGrid::ApplicationUpdateDescriptor&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_updateApplication(const ::IceGrid::ApplicationUpdateDescriptor&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    ICE_GRID_API bool updateApplication_async(const ::IceGrid::AMI_Admin_updateApplicationPtr&, const ::IceGrid::ApplicationUpdateDescriptor&);
    ICE_GRID_API bool updateApplication_async(const ::IceGrid::AMI_Admin_updateApplicationPtr&, const ::IceGrid::ApplicationUpdateDescriptor&, const ::Ice::Context&);

    void removeApplication(const ::std::string& name)
    {
        removeApplication(name, 0);
    }
    void removeApplication(const ::std::string& name, const ::Ice::Context& __ctx)
    {
        removeApplication(name, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_removeApplication(const ::std::string& name)
    {
        return begin_removeApplication(name, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_removeApplication(const ::std::string& name, const ::Ice::Context& __ctx)
    {
        return begin_removeApplication(name, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_removeApplication(const ::std::string& name, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_removeApplication(name, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_removeApplication(const ::std::string& name, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_removeApplication(name, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_removeApplication(const ::std::string& name, const ::IceGrid::Callback_Admin_removeApplicationPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_removeApplication(name, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_removeApplication(const ::std::string& name, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_removeApplicationPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_removeApplication(name, &__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_removeApplication(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void removeApplication(const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_removeApplication(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    ICE_GRID_API bool removeApplication_async(const ::IceGrid::AMI_Admin_removeApplicationPtr&, const ::std::string&);
    ICE_GRID_API bool removeApplication_async(const ::IceGrid::AMI_Admin_removeApplicationPtr&, const ::std::string&, const ::Ice::Context&);

    void instantiateServer(const ::std::string& application, const ::std::string& node, const ::IceGrid::ServerInstanceDescriptor& desc)
    {
        instantiateServer(application, node, desc, 0);
    }
    void instantiateServer(const ::std::string& application, const ::std::string& node, const ::IceGrid::ServerInstanceDescriptor& desc, const ::Ice::Context& __ctx)
    {
        instantiateServer(application, node, desc, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_instantiateServer(const ::std::string& application, const ::std::string& node, const ::IceGrid::ServerInstanceDescriptor& desc)
    {
        return begin_instantiateServer(application, node, desc, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_instantiateServer(const ::std::string& application, const ::std::string& node, const ::IceGrid::ServerInstanceDescriptor& desc, const ::Ice::Context& __ctx)
    {
        return begin_instantiateServer(application, node, desc, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_instantiateServer(const ::std::string& application, const ::std::string& node, const ::IceGrid::ServerInstanceDescriptor& desc, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_instantiateServer(application, node, desc, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_instantiateServer(const ::std::string& application, const ::std::string& node, const ::IceGrid::ServerInstanceDescriptor& desc, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_instantiateServer(application, node, desc, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_instantiateServer(const ::std::string& application, const ::std::string& node, const ::IceGrid::ServerInstanceDescriptor& desc, const ::IceGrid::Callback_Admin_instantiateServerPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_instantiateServer(application, node, desc, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_instantiateServer(const ::std::string& application, const ::std::string& node, const ::IceGrid::ServerInstanceDescriptor& desc, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_instantiateServerPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_instantiateServer(application, node, desc, &__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_instantiateServer(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void instantiateServer(const ::std::string&, const ::std::string&, const ::IceGrid::ServerInstanceDescriptor&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_instantiateServer(const ::std::string&, const ::std::string&, const ::IceGrid::ServerInstanceDescriptor&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    void patchApplication(const ::std::string& name, bool shutdown)
    {
        patchApplication(name, shutdown, 0);
    }
    void patchApplication(const ::std::string& name, bool shutdown, const ::Ice::Context& __ctx)
    {
        patchApplication(name, shutdown, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_patchApplication(const ::std::string& name, bool shutdown)
    {
        return begin_patchApplication(name, shutdown, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_patchApplication(const ::std::string& name, bool shutdown, const ::Ice::Context& __ctx)
    {
        return begin_patchApplication(name, shutdown, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_patchApplication(const ::std::string& name, bool shutdown, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_patchApplication(name, shutdown, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_patchApplication(const ::std::string& name, bool shutdown, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_patchApplication(name, shutdown, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_patchApplication(const ::std::string& name, bool shutdown, const ::IceGrid::Callback_Admin_patchApplicationPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_patchApplication(name, shutdown, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_patchApplication(const ::std::string& name, bool shutdown, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_patchApplicationPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_patchApplication(name, shutdown, &__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_patchApplication(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void patchApplication(const ::std::string&, bool, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_patchApplication(const ::std::string&, bool, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    ICE_GRID_API bool patchApplication_async(const ::IceGrid::AMI_Admin_patchApplicationPtr&, const ::std::string&, bool);
    ICE_GRID_API bool patchApplication_async(const ::IceGrid::AMI_Admin_patchApplicationPtr&, const ::std::string&, bool, const ::Ice::Context&);

    ::IceGrid::ApplicationInfo getApplicationInfo(const ::std::string& name)
    {
        return getApplicationInfo(name, 0);
    }
    ::IceGrid::ApplicationInfo getApplicationInfo(const ::std::string& name, const ::Ice::Context& __ctx)
    {
        return getApplicationInfo(name, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_getApplicationInfo(const ::std::string& name)
    {
        return begin_getApplicationInfo(name, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getApplicationInfo(const ::std::string& name, const ::Ice::Context& __ctx)
    {
        return begin_getApplicationInfo(name, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getApplicationInfo(const ::std::string& name, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getApplicationInfo(name, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getApplicationInfo(const ::std::string& name, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getApplicationInfo(name, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getApplicationInfo(const ::std::string& name, const ::IceGrid::Callback_Admin_getApplicationInfoPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getApplicationInfo(name, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getApplicationInfo(const ::std::string& name, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_getApplicationInfoPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getApplicationInfo(name, &__ctx, __del, __cookie);
    }

    ICE_GRID_API ::IceGrid::ApplicationInfo end_getApplicationInfo(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::IceGrid::ApplicationInfo getApplicationInfo(const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getApplicationInfo(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::IceGrid::ApplicationDescriptor getDefaultApplicationDescriptor()
    {
        return getDefaultApplicationDescriptor(0);
    }
    ::IceGrid::ApplicationDescriptor getDefaultApplicationDescriptor(const ::Ice::Context& __ctx)
    {
        return getDefaultApplicationDescriptor(&__ctx);
    }

    ::Ice::AsyncResultPtr begin_getDefaultApplicationDescriptor()
    {
        return begin_getDefaultApplicationDescriptor(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getDefaultApplicationDescriptor(const ::Ice::Context& __ctx)
    {
        return begin_getDefaultApplicationDescriptor(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getDefaultApplicationDescriptor(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getDefaultApplicationDescriptor(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getDefaultApplicationDescriptor(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getDefaultApplicationDescriptor(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getDefaultApplicationDescriptor(const ::IceGrid::Callback_Admin_getDefaultApplicationDescriptorPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getDefaultApplicationDescriptor(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getDefaultApplicationDescriptor(const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_getDefaultApplicationDescriptorPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getDefaultApplicationDescriptor(&__ctx, __del, __cookie);
    }

    ICE_GRID_API ::IceGrid::ApplicationDescriptor end_getDefaultApplicationDescriptor(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::IceGrid::ApplicationDescriptor getDefaultApplicationDescriptor(const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getDefaultApplicationDescriptor(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::Ice::StringSeq getAllApplicationNames()
    {
        return getAllApplicationNames(0);
    }
    ::Ice::StringSeq getAllApplicationNames(const ::Ice::Context& __ctx)
    {
        return getAllApplicationNames(&__ctx);
    }

    ::Ice::AsyncResultPtr begin_getAllApplicationNames()
    {
        return begin_getAllApplicationNames(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getAllApplicationNames(const ::Ice::Context& __ctx)
    {
        return begin_getAllApplicationNames(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getAllApplicationNames(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllApplicationNames(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAllApplicationNames(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllApplicationNames(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAllApplicationNames(const ::IceGrid::Callback_Admin_getAllApplicationNamesPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllApplicationNames(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAllApplicationNames(const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_getAllApplicationNamesPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllApplicationNames(&__ctx, __del, __cookie);
    }

    ICE_GRID_API ::Ice::StringSeq end_getAllApplicationNames(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::Ice::StringSeq getAllApplicationNames(const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getAllApplicationNames(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::IceGrid::ServerInfo getServerInfo(const ::std::string& id)
    {
        return getServerInfo(id, 0);
    }
    ::IceGrid::ServerInfo getServerInfo(const ::std::string& id, const ::Ice::Context& __ctx)
    {
        return getServerInfo(id, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_getServerInfo(const ::std::string& id)
    {
        return begin_getServerInfo(id, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getServerInfo(const ::std::string& id, const ::Ice::Context& __ctx)
    {
        return begin_getServerInfo(id, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getServerInfo(const ::std::string& id, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getServerInfo(id, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getServerInfo(const ::std::string& id, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getServerInfo(id, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getServerInfo(const ::std::string& id, const ::IceGrid::Callback_Admin_getServerInfoPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getServerInfo(id, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getServerInfo(const ::std::string& id, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_getServerInfoPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getServerInfo(id, &__ctx, __del, __cookie);
    }

    ICE_GRID_API ::IceGrid::ServerInfo end_getServerInfo(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::IceGrid::ServerInfo getServerInfo(const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getServerInfo(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::IceGrid::ServerState getServerState(const ::std::string& id)
    {
        return getServerState(id, 0);
    }
    ::IceGrid::ServerState getServerState(const ::std::string& id, const ::Ice::Context& __ctx)
    {
        return getServerState(id, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_getServerState(const ::std::string& id)
    {
        return begin_getServerState(id, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getServerState(const ::std::string& id, const ::Ice::Context& __ctx)
    {
        return begin_getServerState(id, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getServerState(const ::std::string& id, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getServerState(id, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getServerState(const ::std::string& id, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getServerState(id, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getServerState(const ::std::string& id, const ::IceGrid::Callback_Admin_getServerStatePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getServerState(id, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getServerState(const ::std::string& id, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_getServerStatePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getServerState(id, &__ctx, __del, __cookie);
    }

    ICE_GRID_API ::IceGrid::ServerState end_getServerState(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::IceGrid::ServerState getServerState(const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getServerState(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::Ice::Int getServerPid(const ::std::string& id)
    {
        return getServerPid(id, 0);
    }
    ::Ice::Int getServerPid(const ::std::string& id, const ::Ice::Context& __ctx)
    {
        return getServerPid(id, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_getServerPid(const ::std::string& id)
    {
        return begin_getServerPid(id, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getServerPid(const ::std::string& id, const ::Ice::Context& __ctx)
    {
        return begin_getServerPid(id, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getServerPid(const ::std::string& id, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getServerPid(id, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getServerPid(const ::std::string& id, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getServerPid(id, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getServerPid(const ::std::string& id, const ::IceGrid::Callback_Admin_getServerPidPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getServerPid(id, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getServerPid(const ::std::string& id, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_getServerPidPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getServerPid(id, &__ctx, __del, __cookie);
    }

    ICE_GRID_API ::Ice::Int end_getServerPid(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::Ice::Int getServerPid(const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getServerPid(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::std::string getServerAdminCategory()
    {
        return getServerAdminCategory(0);
    }
    ::std::string getServerAdminCategory(const ::Ice::Context& __ctx)
    {
        return getServerAdminCategory(&__ctx);
    }

    ::Ice::AsyncResultPtr begin_getServerAdminCategory()
    {
        return begin_getServerAdminCategory(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getServerAdminCategory(const ::Ice::Context& __ctx)
    {
        return begin_getServerAdminCategory(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getServerAdminCategory(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getServerAdminCategory(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getServerAdminCategory(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getServerAdminCategory(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getServerAdminCategory(const ::IceGrid::Callback_Admin_getServerAdminCategoryPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getServerAdminCategory(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getServerAdminCategory(const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_getServerAdminCategoryPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getServerAdminCategory(&__ctx, __del, __cookie);
    }

    ICE_GRID_API ::std::string end_getServerAdminCategory(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::std::string getServerAdminCategory(const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getServerAdminCategory(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::Ice::ObjectPrx getServerAdmin(const ::std::string& id)
    {
        return getServerAdmin(id, 0);
    }
    ::Ice::ObjectPrx getServerAdmin(const ::std::string& id, const ::Ice::Context& __ctx)
    {
        return getServerAdmin(id, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_getServerAdmin(const ::std::string& id)
    {
        return begin_getServerAdmin(id, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getServerAdmin(const ::std::string& id, const ::Ice::Context& __ctx)
    {
        return begin_getServerAdmin(id, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getServerAdmin(const ::std::string& id, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getServerAdmin(id, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getServerAdmin(const ::std::string& id, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getServerAdmin(id, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getServerAdmin(const ::std::string& id, const ::IceGrid::Callback_Admin_getServerAdminPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getServerAdmin(id, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getServerAdmin(const ::std::string& id, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_getServerAdminPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getServerAdmin(id, &__ctx, __del, __cookie);
    }

    ICE_GRID_API ::Ice::ObjectPrx end_getServerAdmin(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::Ice::ObjectPrx getServerAdmin(const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getServerAdmin(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    void enableServer(const ::std::string& id, bool enabled)
    {
        enableServer(id, enabled, 0);
    }
    void enableServer(const ::std::string& id, bool enabled, const ::Ice::Context& __ctx)
    {
        enableServer(id, enabled, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_enableServer(const ::std::string& id, bool enabled)
    {
        return begin_enableServer(id, enabled, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_enableServer(const ::std::string& id, bool enabled, const ::Ice::Context& __ctx)
    {
        return begin_enableServer(id, enabled, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_enableServer(const ::std::string& id, bool enabled, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_enableServer(id, enabled, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_enableServer(const ::std::string& id, bool enabled, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_enableServer(id, enabled, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_enableServer(const ::std::string& id, bool enabled, const ::IceGrid::Callback_Admin_enableServerPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_enableServer(id, enabled, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_enableServer(const ::std::string& id, bool enabled, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_enableServerPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_enableServer(id, enabled, &__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_enableServer(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void enableServer(const ::std::string&, bool, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_enableServer(const ::std::string&, bool, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    ICE_GRID_API bool enableServer_async(const ::IceGrid::AMI_Admin_enableServerPtr&, const ::std::string&, bool);
    ICE_GRID_API bool enableServer_async(const ::IceGrid::AMI_Admin_enableServerPtr&, const ::std::string&, bool, const ::Ice::Context&);

    bool isServerEnabled(const ::std::string& id)
    {
        return isServerEnabled(id, 0);
    }
    bool isServerEnabled(const ::std::string& id, const ::Ice::Context& __ctx)
    {
        return isServerEnabled(id, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_isServerEnabled(const ::std::string& id)
    {
        return begin_isServerEnabled(id, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_isServerEnabled(const ::std::string& id, const ::Ice::Context& __ctx)
    {
        return begin_isServerEnabled(id, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_isServerEnabled(const ::std::string& id, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_isServerEnabled(id, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_isServerEnabled(const ::std::string& id, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_isServerEnabled(id, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_isServerEnabled(const ::std::string& id, const ::IceGrid::Callback_Admin_isServerEnabledPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_isServerEnabled(id, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_isServerEnabled(const ::std::string& id, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_isServerEnabledPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_isServerEnabled(id, &__ctx, __del, __cookie);
    }

    ICE_GRID_API bool end_isServerEnabled(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API bool isServerEnabled(const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_isServerEnabled(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    void startServer(const ::std::string& id)
    {
        startServer(id, 0);
    }
    void startServer(const ::std::string& id, const ::Ice::Context& __ctx)
    {
        startServer(id, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_startServer(const ::std::string& id)
    {
        return begin_startServer(id, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_startServer(const ::std::string& id, const ::Ice::Context& __ctx)
    {
        return begin_startServer(id, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_startServer(const ::std::string& id, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_startServer(id, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_startServer(const ::std::string& id, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_startServer(id, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_startServer(const ::std::string& id, const ::IceGrid::Callback_Admin_startServerPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_startServer(id, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_startServer(const ::std::string& id, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_startServerPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_startServer(id, &__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_startServer(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void startServer(const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_startServer(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    ICE_GRID_API bool startServer_async(const ::IceGrid::AMI_Admin_startServerPtr&, const ::std::string&);
    ICE_GRID_API bool startServer_async(const ::IceGrid::AMI_Admin_startServerPtr&, const ::std::string&, const ::Ice::Context&);

    void stopServer(const ::std::string& id)
    {
        stopServer(id, 0);
    }
    void stopServer(const ::std::string& id, const ::Ice::Context& __ctx)
    {
        stopServer(id, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_stopServer(const ::std::string& id)
    {
        return begin_stopServer(id, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_stopServer(const ::std::string& id, const ::Ice::Context& __ctx)
    {
        return begin_stopServer(id, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_stopServer(const ::std::string& id, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_stopServer(id, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_stopServer(const ::std::string& id, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_stopServer(id, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_stopServer(const ::std::string& id, const ::IceGrid::Callback_Admin_stopServerPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_stopServer(id, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_stopServer(const ::std::string& id, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_stopServerPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_stopServer(id, &__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_stopServer(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void stopServer(const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_stopServer(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    ICE_GRID_API bool stopServer_async(const ::IceGrid::AMI_Admin_stopServerPtr&, const ::std::string&);
    ICE_GRID_API bool stopServer_async(const ::IceGrid::AMI_Admin_stopServerPtr&, const ::std::string&, const ::Ice::Context&);

    void patchServer(const ::std::string& id, bool shutdown)
    {
        patchServer(id, shutdown, 0);
    }
    void patchServer(const ::std::string& id, bool shutdown, const ::Ice::Context& __ctx)
    {
        patchServer(id, shutdown, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_patchServer(const ::std::string& id, bool shutdown)
    {
        return begin_patchServer(id, shutdown, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_patchServer(const ::std::string& id, bool shutdown, const ::Ice::Context& __ctx)
    {
        return begin_patchServer(id, shutdown, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_patchServer(const ::std::string& id, bool shutdown, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_patchServer(id, shutdown, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_patchServer(const ::std::string& id, bool shutdown, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_patchServer(id, shutdown, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_patchServer(const ::std::string& id, bool shutdown, const ::IceGrid::Callback_Admin_patchServerPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_patchServer(id, shutdown, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_patchServer(const ::std::string& id, bool shutdown, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_patchServerPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_patchServer(id, shutdown, &__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_patchServer(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void patchServer(const ::std::string&, bool, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_patchServer(const ::std::string&, bool, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    ICE_GRID_API bool patchServer_async(const ::IceGrid::AMI_Admin_patchServerPtr&, const ::std::string&, bool);
    ICE_GRID_API bool patchServer_async(const ::IceGrid::AMI_Admin_patchServerPtr&, const ::std::string&, bool, const ::Ice::Context&);

    void sendSignal(const ::std::string& id, const ::std::string& signal)
    {
        sendSignal(id, signal, 0);
    }
    void sendSignal(const ::std::string& id, const ::std::string& signal, const ::Ice::Context& __ctx)
    {
        sendSignal(id, signal, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_sendSignal(const ::std::string& id, const ::std::string& signal)
    {
        return begin_sendSignal(id, signal, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_sendSignal(const ::std::string& id, const ::std::string& signal, const ::Ice::Context& __ctx)
    {
        return begin_sendSignal(id, signal, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_sendSignal(const ::std::string& id, const ::std::string& signal, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_sendSignal(id, signal, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_sendSignal(const ::std::string& id, const ::std::string& signal, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_sendSignal(id, signal, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_sendSignal(const ::std::string& id, const ::std::string& signal, const ::IceGrid::Callback_Admin_sendSignalPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_sendSignal(id, signal, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_sendSignal(const ::std::string& id, const ::std::string& signal, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_sendSignalPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_sendSignal(id, signal, &__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_sendSignal(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void sendSignal(const ::std::string&, const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_sendSignal(const ::std::string&, const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    ICE_GRID_API bool sendSignal_async(const ::IceGrid::AMI_Admin_sendSignalPtr&, const ::std::string&, const ::std::string&);
    ICE_GRID_API bool sendSignal_async(const ::IceGrid::AMI_Admin_sendSignalPtr&, const ::std::string&, const ::std::string&, const ::Ice::Context&);

    ICE_DEPRECATED_API void writeMessage(const ::std::string& id, const ::std::string& message, ::Ice::Int fd)
    {
        writeMessage(id, message, fd, 0);
    }
    ICE_DEPRECATED_API void writeMessage(const ::std::string& id, const ::std::string& message, ::Ice::Int fd, const ::Ice::Context& __ctx)
    {
        writeMessage(id, message, fd, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_writeMessage(const ::std::string& id, const ::std::string& message, ::Ice::Int fd)
    {
        return begin_writeMessage(id, message, fd, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_writeMessage(const ::std::string& id, const ::std::string& message, ::Ice::Int fd, const ::Ice::Context& __ctx)
    {
        return begin_writeMessage(id, message, fd, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_writeMessage(const ::std::string& id, const ::std::string& message, ::Ice::Int fd, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_writeMessage(id, message, fd, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_writeMessage(const ::std::string& id, const ::std::string& message, ::Ice::Int fd, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_writeMessage(id, message, fd, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_writeMessage(const ::std::string& id, const ::std::string& message, ::Ice::Int fd, const ::IceGrid::Callback_Admin_writeMessagePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_writeMessage(id, message, fd, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_writeMessage(const ::std::string& id, const ::std::string& message, ::Ice::Int fd, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_writeMessagePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_writeMessage(id, message, fd, &__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_writeMessage(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void writeMessage(const ::std::string&, const ::std::string&, ::Ice::Int, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_writeMessage(const ::std::string&, const ::std::string&, ::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    ICE_GRID_API bool writeMessage_async(const ::IceGrid::AMI_Admin_writeMessagePtr&, const ::std::string&, const ::std::string&, ::Ice::Int);
    ICE_GRID_API bool writeMessage_async(const ::IceGrid::AMI_Admin_writeMessagePtr&, const ::std::string&, const ::std::string&, ::Ice::Int, const ::Ice::Context&);

    ::Ice::StringSeq getAllServerIds()
    {
        return getAllServerIds(0);
    }
    ::Ice::StringSeq getAllServerIds(const ::Ice::Context& __ctx)
    {
        return getAllServerIds(&__ctx);
    }

    ::Ice::AsyncResultPtr begin_getAllServerIds()
    {
        return begin_getAllServerIds(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getAllServerIds(const ::Ice::Context& __ctx)
    {
        return begin_getAllServerIds(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getAllServerIds(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllServerIds(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAllServerIds(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllServerIds(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAllServerIds(const ::IceGrid::Callback_Admin_getAllServerIdsPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllServerIds(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAllServerIds(const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_getAllServerIdsPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllServerIds(&__ctx, __del, __cookie);
    }

    ICE_GRID_API ::Ice::StringSeq end_getAllServerIds(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::Ice::StringSeq getAllServerIds(const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getAllServerIds(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::IceGrid::AdapterInfoSeq getAdapterInfo(const ::std::string& id)
    {
        return getAdapterInfo(id, 0);
    }
    ::IceGrid::AdapterInfoSeq getAdapterInfo(const ::std::string& id, const ::Ice::Context& __ctx)
    {
        return getAdapterInfo(id, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_getAdapterInfo(const ::std::string& id)
    {
        return begin_getAdapterInfo(id, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getAdapterInfo(const ::std::string& id, const ::Ice::Context& __ctx)
    {
        return begin_getAdapterInfo(id, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getAdapterInfo(const ::std::string& id, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAdapterInfo(id, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAdapterInfo(const ::std::string& id, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAdapterInfo(id, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAdapterInfo(const ::std::string& id, const ::IceGrid::Callback_Admin_getAdapterInfoPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAdapterInfo(id, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAdapterInfo(const ::std::string& id, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_getAdapterInfoPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAdapterInfo(id, &__ctx, __del, __cookie);
    }

    ICE_GRID_API ::IceGrid::AdapterInfoSeq end_getAdapterInfo(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::IceGrid::AdapterInfoSeq getAdapterInfo(const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getAdapterInfo(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    void removeAdapter(const ::std::string& id)
    {
        removeAdapter(id, 0);
    }
    void removeAdapter(const ::std::string& id, const ::Ice::Context& __ctx)
    {
        removeAdapter(id, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_removeAdapter(const ::std::string& id)
    {
        return begin_removeAdapter(id, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_removeAdapter(const ::std::string& id, const ::Ice::Context& __ctx)
    {
        return begin_removeAdapter(id, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_removeAdapter(const ::std::string& id, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_removeAdapter(id, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_removeAdapter(const ::std::string& id, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_removeAdapter(id, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_removeAdapter(const ::std::string& id, const ::IceGrid::Callback_Admin_removeAdapterPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_removeAdapter(id, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_removeAdapter(const ::std::string& id, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_removeAdapterPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_removeAdapter(id, &__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_removeAdapter(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void removeAdapter(const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_removeAdapter(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    ICE_GRID_API bool removeAdapter_async(const ::IceGrid::AMI_Admin_removeAdapterPtr&, const ::std::string&);
    ICE_GRID_API bool removeAdapter_async(const ::IceGrid::AMI_Admin_removeAdapterPtr&, const ::std::string&, const ::Ice::Context&);

    ::Ice::StringSeq getAllAdapterIds()
    {
        return getAllAdapterIds(0);
    }
    ::Ice::StringSeq getAllAdapterIds(const ::Ice::Context& __ctx)
    {
        return getAllAdapterIds(&__ctx);
    }

    ::Ice::AsyncResultPtr begin_getAllAdapterIds()
    {
        return begin_getAllAdapterIds(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getAllAdapterIds(const ::Ice::Context& __ctx)
    {
        return begin_getAllAdapterIds(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getAllAdapterIds(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllAdapterIds(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAllAdapterIds(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllAdapterIds(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAllAdapterIds(const ::IceGrid::Callback_Admin_getAllAdapterIdsPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllAdapterIds(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAllAdapterIds(const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_getAllAdapterIdsPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllAdapterIds(&__ctx, __del, __cookie);
    }

    ICE_GRID_API ::Ice::StringSeq end_getAllAdapterIds(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::Ice::StringSeq getAllAdapterIds(const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getAllAdapterIds(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    void addObject(const ::Ice::ObjectPrx& obj)
    {
        addObject(obj, 0);
    }
    void addObject(const ::Ice::ObjectPrx& obj, const ::Ice::Context& __ctx)
    {
        addObject(obj, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_addObject(const ::Ice::ObjectPrx& obj)
    {
        return begin_addObject(obj, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_addObject(const ::Ice::ObjectPrx& obj, const ::Ice::Context& __ctx)
    {
        return begin_addObject(obj, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_addObject(const ::Ice::ObjectPrx& obj, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_addObject(obj, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_addObject(const ::Ice::ObjectPrx& obj, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_addObject(obj, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_addObject(const ::Ice::ObjectPrx& obj, const ::IceGrid::Callback_Admin_addObjectPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_addObject(obj, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_addObject(const ::Ice::ObjectPrx& obj, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_addObjectPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_addObject(obj, &__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_addObject(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void addObject(const ::Ice::ObjectPrx&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_addObject(const ::Ice::ObjectPrx&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    ICE_GRID_API bool addObject_async(const ::IceGrid::AMI_Admin_addObjectPtr&, const ::Ice::ObjectPrx&);
    ICE_GRID_API bool addObject_async(const ::IceGrid::AMI_Admin_addObjectPtr&, const ::Ice::ObjectPrx&, const ::Ice::Context&);

    void updateObject(const ::Ice::ObjectPrx& obj)
    {
        updateObject(obj, 0);
    }
    void updateObject(const ::Ice::ObjectPrx& obj, const ::Ice::Context& __ctx)
    {
        updateObject(obj, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_updateObject(const ::Ice::ObjectPrx& obj)
    {
        return begin_updateObject(obj, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_updateObject(const ::Ice::ObjectPrx& obj, const ::Ice::Context& __ctx)
    {
        return begin_updateObject(obj, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_updateObject(const ::Ice::ObjectPrx& obj, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_updateObject(obj, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_updateObject(const ::Ice::ObjectPrx& obj, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_updateObject(obj, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_updateObject(const ::Ice::ObjectPrx& obj, const ::IceGrid::Callback_Admin_updateObjectPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_updateObject(obj, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_updateObject(const ::Ice::ObjectPrx& obj, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_updateObjectPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_updateObject(obj, &__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_updateObject(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void updateObject(const ::Ice::ObjectPrx&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_updateObject(const ::Ice::ObjectPrx&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    void addObjectWithType(const ::Ice::ObjectPrx& obj, const ::std::string& type)
    {
        addObjectWithType(obj, type, 0);
    }
    void addObjectWithType(const ::Ice::ObjectPrx& obj, const ::std::string& type, const ::Ice::Context& __ctx)
    {
        addObjectWithType(obj, type, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_addObjectWithType(const ::Ice::ObjectPrx& obj, const ::std::string& type)
    {
        return begin_addObjectWithType(obj, type, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_addObjectWithType(const ::Ice::ObjectPrx& obj, const ::std::string& type, const ::Ice::Context& __ctx)
    {
        return begin_addObjectWithType(obj, type, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_addObjectWithType(const ::Ice::ObjectPrx& obj, const ::std::string& type, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_addObjectWithType(obj, type, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_addObjectWithType(const ::Ice::ObjectPrx& obj, const ::std::string& type, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_addObjectWithType(obj, type, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_addObjectWithType(const ::Ice::ObjectPrx& obj, const ::std::string& type, const ::IceGrid::Callback_Admin_addObjectWithTypePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_addObjectWithType(obj, type, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_addObjectWithType(const ::Ice::ObjectPrx& obj, const ::std::string& type, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_addObjectWithTypePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_addObjectWithType(obj, type, &__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_addObjectWithType(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void addObjectWithType(const ::Ice::ObjectPrx&, const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_addObjectWithType(const ::Ice::ObjectPrx&, const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    ICE_GRID_API bool addObjectWithType_async(const ::IceGrid::AMI_Admin_addObjectWithTypePtr&, const ::Ice::ObjectPrx&, const ::std::string&);
    ICE_GRID_API bool addObjectWithType_async(const ::IceGrid::AMI_Admin_addObjectWithTypePtr&, const ::Ice::ObjectPrx&, const ::std::string&, const ::Ice::Context&);

    void removeObject(const ::Ice::Identity& id)
    {
        removeObject(id, 0);
    }
    void removeObject(const ::Ice::Identity& id, const ::Ice::Context& __ctx)
    {
        removeObject(id, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_removeObject(const ::Ice::Identity& id)
    {
        return begin_removeObject(id, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_removeObject(const ::Ice::Identity& id, const ::Ice::Context& __ctx)
    {
        return begin_removeObject(id, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_removeObject(const ::Ice::Identity& id, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_removeObject(id, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_removeObject(const ::Ice::Identity& id, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_removeObject(id, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_removeObject(const ::Ice::Identity& id, const ::IceGrid::Callback_Admin_removeObjectPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_removeObject(id, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_removeObject(const ::Ice::Identity& id, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_removeObjectPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_removeObject(id, &__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_removeObject(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void removeObject(const ::Ice::Identity&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_removeObject(const ::Ice::Identity&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    ICE_GRID_API bool removeObject_async(const ::IceGrid::AMI_Admin_removeObjectPtr&, const ::Ice::Identity&);
    ICE_GRID_API bool removeObject_async(const ::IceGrid::AMI_Admin_removeObjectPtr&, const ::Ice::Identity&, const ::Ice::Context&);

    ::IceGrid::ObjectInfo getObjectInfo(const ::Ice::Identity& id)
    {
        return getObjectInfo(id, 0);
    }
    ::IceGrid::ObjectInfo getObjectInfo(const ::Ice::Identity& id, const ::Ice::Context& __ctx)
    {
        return getObjectInfo(id, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_getObjectInfo(const ::Ice::Identity& id)
    {
        return begin_getObjectInfo(id, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getObjectInfo(const ::Ice::Identity& id, const ::Ice::Context& __ctx)
    {
        return begin_getObjectInfo(id, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getObjectInfo(const ::Ice::Identity& id, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getObjectInfo(id, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getObjectInfo(const ::Ice::Identity& id, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getObjectInfo(id, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getObjectInfo(const ::Ice::Identity& id, const ::IceGrid::Callback_Admin_getObjectInfoPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getObjectInfo(id, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getObjectInfo(const ::Ice::Identity& id, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_getObjectInfoPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getObjectInfo(id, &__ctx, __del, __cookie);
    }

    ICE_GRID_API ::IceGrid::ObjectInfo end_getObjectInfo(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::IceGrid::ObjectInfo getObjectInfo(const ::Ice::Identity&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getObjectInfo(const ::Ice::Identity&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::IceGrid::ObjectInfoSeq getObjectInfosByType(const ::std::string& type)
    {
        return getObjectInfosByType(type, 0);
    }
    ::IceGrid::ObjectInfoSeq getObjectInfosByType(const ::std::string& type, const ::Ice::Context& __ctx)
    {
        return getObjectInfosByType(type, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_getObjectInfosByType(const ::std::string& type)
    {
        return begin_getObjectInfosByType(type, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getObjectInfosByType(const ::std::string& type, const ::Ice::Context& __ctx)
    {
        return begin_getObjectInfosByType(type, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getObjectInfosByType(const ::std::string& type, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getObjectInfosByType(type, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getObjectInfosByType(const ::std::string& type, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getObjectInfosByType(type, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getObjectInfosByType(const ::std::string& type, const ::IceGrid::Callback_Admin_getObjectInfosByTypePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getObjectInfosByType(type, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getObjectInfosByType(const ::std::string& type, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_getObjectInfosByTypePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getObjectInfosByType(type, &__ctx, __del, __cookie);
    }

    ICE_GRID_API ::IceGrid::ObjectInfoSeq end_getObjectInfosByType(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::IceGrid::ObjectInfoSeq getObjectInfosByType(const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getObjectInfosByType(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::IceGrid::ObjectInfoSeq getAllObjectInfos(const ::std::string& expr)
    {
        return getAllObjectInfos(expr, 0);
    }
    ::IceGrid::ObjectInfoSeq getAllObjectInfos(const ::std::string& expr, const ::Ice::Context& __ctx)
    {
        return getAllObjectInfos(expr, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_getAllObjectInfos(const ::std::string& expr)
    {
        return begin_getAllObjectInfos(expr, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getAllObjectInfos(const ::std::string& expr, const ::Ice::Context& __ctx)
    {
        return begin_getAllObjectInfos(expr, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getAllObjectInfos(const ::std::string& expr, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllObjectInfos(expr, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAllObjectInfos(const ::std::string& expr, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllObjectInfos(expr, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAllObjectInfos(const ::std::string& expr, const ::IceGrid::Callback_Admin_getAllObjectInfosPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllObjectInfos(expr, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAllObjectInfos(const ::std::string& expr, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_getAllObjectInfosPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllObjectInfos(expr, &__ctx, __del, __cookie);
    }

    ICE_GRID_API ::IceGrid::ObjectInfoSeq end_getAllObjectInfos(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::IceGrid::ObjectInfoSeq getAllObjectInfos(const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getAllObjectInfos(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    bool pingNode(const ::std::string& name)
    {
        return pingNode(name, 0);
    }
    bool pingNode(const ::std::string& name, const ::Ice::Context& __ctx)
    {
        return pingNode(name, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_pingNode(const ::std::string& name)
    {
        return begin_pingNode(name, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_pingNode(const ::std::string& name, const ::Ice::Context& __ctx)
    {
        return begin_pingNode(name, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_pingNode(const ::std::string& name, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_pingNode(name, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_pingNode(const ::std::string& name, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_pingNode(name, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_pingNode(const ::std::string& name, const ::IceGrid::Callback_Admin_pingNodePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_pingNode(name, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_pingNode(const ::std::string& name, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_pingNodePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_pingNode(name, &__ctx, __del, __cookie);
    }

    ICE_GRID_API bool end_pingNode(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API bool pingNode(const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_pingNode(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::IceGrid::LoadInfo getNodeLoad(const ::std::string& name)
    {
        return getNodeLoad(name, 0);
    }
    ::IceGrid::LoadInfo getNodeLoad(const ::std::string& name, const ::Ice::Context& __ctx)
    {
        return getNodeLoad(name, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_getNodeLoad(const ::std::string& name)
    {
        return begin_getNodeLoad(name, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getNodeLoad(const ::std::string& name, const ::Ice::Context& __ctx)
    {
        return begin_getNodeLoad(name, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getNodeLoad(const ::std::string& name, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getNodeLoad(name, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getNodeLoad(const ::std::string& name, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getNodeLoad(name, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getNodeLoad(const ::std::string& name, const ::IceGrid::Callback_Admin_getNodeLoadPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getNodeLoad(name, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getNodeLoad(const ::std::string& name, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_getNodeLoadPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getNodeLoad(name, &__ctx, __del, __cookie);
    }

    ICE_GRID_API ::IceGrid::LoadInfo end_getNodeLoad(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::IceGrid::LoadInfo getNodeLoad(const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getNodeLoad(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    ICE_GRID_API bool getNodeLoad_async(const ::IceGrid::AMI_Admin_getNodeLoadPtr&, const ::std::string&);
    ICE_GRID_API bool getNodeLoad_async(const ::IceGrid::AMI_Admin_getNodeLoadPtr&, const ::std::string&, const ::Ice::Context&);

    ::IceGrid::NodeInfo getNodeInfo(const ::std::string& name)
    {
        return getNodeInfo(name, 0);
    }
    ::IceGrid::NodeInfo getNodeInfo(const ::std::string& name, const ::Ice::Context& __ctx)
    {
        return getNodeInfo(name, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_getNodeInfo(const ::std::string& name)
    {
        return begin_getNodeInfo(name, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getNodeInfo(const ::std::string& name, const ::Ice::Context& __ctx)
    {
        return begin_getNodeInfo(name, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getNodeInfo(const ::std::string& name, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getNodeInfo(name, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getNodeInfo(const ::std::string& name, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getNodeInfo(name, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getNodeInfo(const ::std::string& name, const ::IceGrid::Callback_Admin_getNodeInfoPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getNodeInfo(name, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getNodeInfo(const ::std::string& name, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_getNodeInfoPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getNodeInfo(name, &__ctx, __del, __cookie);
    }

    ICE_GRID_API ::IceGrid::NodeInfo end_getNodeInfo(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::IceGrid::NodeInfo getNodeInfo(const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getNodeInfo(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::Ice::Int getNodeProcessorSocketCount(const ::std::string& name)
    {
        return getNodeProcessorSocketCount(name, 0);
    }
    ::Ice::Int getNodeProcessorSocketCount(const ::std::string& name, const ::Ice::Context& __ctx)
    {
        return getNodeProcessorSocketCount(name, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_getNodeProcessorSocketCount(const ::std::string& name)
    {
        return begin_getNodeProcessorSocketCount(name, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getNodeProcessorSocketCount(const ::std::string& name, const ::Ice::Context& __ctx)
    {
        return begin_getNodeProcessorSocketCount(name, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getNodeProcessorSocketCount(const ::std::string& name, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getNodeProcessorSocketCount(name, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getNodeProcessorSocketCount(const ::std::string& name, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getNodeProcessorSocketCount(name, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getNodeProcessorSocketCount(const ::std::string& name, const ::IceGrid::Callback_Admin_getNodeProcessorSocketCountPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getNodeProcessorSocketCount(name, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getNodeProcessorSocketCount(const ::std::string& name, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_getNodeProcessorSocketCountPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getNodeProcessorSocketCount(name, &__ctx, __del, __cookie);
    }

    ICE_GRID_API ::Ice::Int end_getNodeProcessorSocketCount(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::Ice::Int getNodeProcessorSocketCount(const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getNodeProcessorSocketCount(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    void shutdownNode(const ::std::string& name)
    {
        shutdownNode(name, 0);
    }
    void shutdownNode(const ::std::string& name, const ::Ice::Context& __ctx)
    {
        shutdownNode(name, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_shutdownNode(const ::std::string& name)
    {
        return begin_shutdownNode(name, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_shutdownNode(const ::std::string& name, const ::Ice::Context& __ctx)
    {
        return begin_shutdownNode(name, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_shutdownNode(const ::std::string& name, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_shutdownNode(name, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_shutdownNode(const ::std::string& name, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_shutdownNode(name, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_shutdownNode(const ::std::string& name, const ::IceGrid::Callback_Admin_shutdownNodePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_shutdownNode(name, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_shutdownNode(const ::std::string& name, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_shutdownNodePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_shutdownNode(name, &__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_shutdownNode(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void shutdownNode(const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_shutdownNode(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    ICE_GRID_API bool shutdownNode_async(const ::IceGrid::AMI_Admin_shutdownNodePtr&, const ::std::string&);
    ICE_GRID_API bool shutdownNode_async(const ::IceGrid::AMI_Admin_shutdownNodePtr&, const ::std::string&, const ::Ice::Context&);

    ::std::string getNodeHostname(const ::std::string& name)
    {
        return getNodeHostname(name, 0);
    }
    ::std::string getNodeHostname(const ::std::string& name, const ::Ice::Context& __ctx)
    {
        return getNodeHostname(name, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_getNodeHostname(const ::std::string& name)
    {
        return begin_getNodeHostname(name, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getNodeHostname(const ::std::string& name, const ::Ice::Context& __ctx)
    {
        return begin_getNodeHostname(name, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getNodeHostname(const ::std::string& name, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getNodeHostname(name, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getNodeHostname(const ::std::string& name, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getNodeHostname(name, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getNodeHostname(const ::std::string& name, const ::IceGrid::Callback_Admin_getNodeHostnamePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getNodeHostname(name, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getNodeHostname(const ::std::string& name, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_getNodeHostnamePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getNodeHostname(name, &__ctx, __del, __cookie);
    }

    ICE_GRID_API ::std::string end_getNodeHostname(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::std::string getNodeHostname(const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getNodeHostname(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::Ice::StringSeq getAllNodeNames()
    {
        return getAllNodeNames(0);
    }
    ::Ice::StringSeq getAllNodeNames(const ::Ice::Context& __ctx)
    {
        return getAllNodeNames(&__ctx);
    }

    ::Ice::AsyncResultPtr begin_getAllNodeNames()
    {
        return begin_getAllNodeNames(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getAllNodeNames(const ::Ice::Context& __ctx)
    {
        return begin_getAllNodeNames(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getAllNodeNames(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllNodeNames(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAllNodeNames(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllNodeNames(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAllNodeNames(const ::IceGrid::Callback_Admin_getAllNodeNamesPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllNodeNames(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAllNodeNames(const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_getAllNodeNamesPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllNodeNames(&__ctx, __del, __cookie);
    }

    ICE_GRID_API ::Ice::StringSeq end_getAllNodeNames(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::Ice::StringSeq getAllNodeNames(const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getAllNodeNames(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    bool pingRegistry(const ::std::string& name)
    {
        return pingRegistry(name, 0);
    }
    bool pingRegistry(const ::std::string& name, const ::Ice::Context& __ctx)
    {
        return pingRegistry(name, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_pingRegistry(const ::std::string& name)
    {
        return begin_pingRegistry(name, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_pingRegistry(const ::std::string& name, const ::Ice::Context& __ctx)
    {
        return begin_pingRegistry(name, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_pingRegistry(const ::std::string& name, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_pingRegistry(name, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_pingRegistry(const ::std::string& name, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_pingRegistry(name, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_pingRegistry(const ::std::string& name, const ::IceGrid::Callback_Admin_pingRegistryPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_pingRegistry(name, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_pingRegistry(const ::std::string& name, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_pingRegistryPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_pingRegistry(name, &__ctx, __del, __cookie);
    }

    ICE_GRID_API bool end_pingRegistry(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API bool pingRegistry(const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_pingRegistry(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::IceGrid::RegistryInfo getRegistryInfo(const ::std::string& name)
    {
        return getRegistryInfo(name, 0);
    }
    ::IceGrid::RegistryInfo getRegistryInfo(const ::std::string& name, const ::Ice::Context& __ctx)
    {
        return getRegistryInfo(name, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_getRegistryInfo(const ::std::string& name)
    {
        return begin_getRegistryInfo(name, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getRegistryInfo(const ::std::string& name, const ::Ice::Context& __ctx)
    {
        return begin_getRegistryInfo(name, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getRegistryInfo(const ::std::string& name, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getRegistryInfo(name, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getRegistryInfo(const ::std::string& name, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getRegistryInfo(name, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getRegistryInfo(const ::std::string& name, const ::IceGrid::Callback_Admin_getRegistryInfoPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getRegistryInfo(name, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getRegistryInfo(const ::std::string& name, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_getRegistryInfoPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getRegistryInfo(name, &__ctx, __del, __cookie);
    }

    ICE_GRID_API ::IceGrid::RegistryInfo end_getRegistryInfo(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::IceGrid::RegistryInfo getRegistryInfo(const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getRegistryInfo(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    void shutdownRegistry(const ::std::string& name)
    {
        shutdownRegistry(name, 0);
    }
    void shutdownRegistry(const ::std::string& name, const ::Ice::Context& __ctx)
    {
        shutdownRegistry(name, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_shutdownRegistry(const ::std::string& name)
    {
        return begin_shutdownRegistry(name, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_shutdownRegistry(const ::std::string& name, const ::Ice::Context& __ctx)
    {
        return begin_shutdownRegistry(name, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_shutdownRegistry(const ::std::string& name, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_shutdownRegistry(name, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_shutdownRegistry(const ::std::string& name, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_shutdownRegistry(name, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_shutdownRegistry(const ::std::string& name, const ::IceGrid::Callback_Admin_shutdownRegistryPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_shutdownRegistry(name, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_shutdownRegistry(const ::std::string& name, const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_shutdownRegistryPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_shutdownRegistry(name, &__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_shutdownRegistry(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void shutdownRegistry(const ::std::string&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_shutdownRegistry(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    ICE_GRID_API bool shutdownRegistry_async(const ::IceGrid::AMI_Admin_shutdownRegistryPtr&, const ::std::string&);
    ICE_GRID_API bool shutdownRegistry_async(const ::IceGrid::AMI_Admin_shutdownRegistryPtr&, const ::std::string&, const ::Ice::Context&);

    ::Ice::StringSeq getAllRegistryNames()
    {
        return getAllRegistryNames(0);
    }
    ::Ice::StringSeq getAllRegistryNames(const ::Ice::Context& __ctx)
    {
        return getAllRegistryNames(&__ctx);
    }

    ::Ice::AsyncResultPtr begin_getAllRegistryNames()
    {
        return begin_getAllRegistryNames(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getAllRegistryNames(const ::Ice::Context& __ctx)
    {
        return begin_getAllRegistryNames(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getAllRegistryNames(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllRegistryNames(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAllRegistryNames(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllRegistryNames(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAllRegistryNames(const ::IceGrid::Callback_Admin_getAllRegistryNamesPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllRegistryNames(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAllRegistryNames(const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_getAllRegistryNamesPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAllRegistryNames(&__ctx, __del, __cookie);
    }

    ICE_GRID_API ::Ice::StringSeq end_getAllRegistryNames(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::Ice::StringSeq getAllRegistryNames(const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getAllRegistryNames(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    void shutdown()
    {
        shutdown(0);
    }
    void shutdown(const ::Ice::Context& __ctx)
    {
        shutdown(&__ctx);
    }

    ::Ice::AsyncResultPtr begin_shutdown()
    {
        return begin_shutdown(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_shutdown(const ::Ice::Context& __ctx)
    {
        return begin_shutdown(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_shutdown(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_shutdown(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_shutdown(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_shutdown(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_shutdown(const ::IceGrid::Callback_Admin_shutdownPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_shutdown(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_shutdown(const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_shutdownPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_shutdown(&__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_shutdown(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void shutdown(const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_shutdown(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::Ice::SliceChecksumDict getSliceChecksums()
    {
        return getSliceChecksums(0);
    }
    ::Ice::SliceChecksumDict getSliceChecksums(const ::Ice::Context& __ctx)
    {
        return getSliceChecksums(&__ctx);
    }

    ::Ice::AsyncResultPtr begin_getSliceChecksums()
    {
        return begin_getSliceChecksums(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getSliceChecksums(const ::Ice::Context& __ctx)
    {
        return begin_getSliceChecksums(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getSliceChecksums(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getSliceChecksums(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getSliceChecksums(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getSliceChecksums(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getSliceChecksums(const ::IceGrid::Callback_Admin_getSliceChecksumsPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getSliceChecksums(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getSliceChecksums(const ::Ice::Context& __ctx, const ::IceGrid::Callback_Admin_getSliceChecksumsPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getSliceChecksums(&__ctx, __del, __cookie);
    }

    ICE_GRID_API ::Ice::SliceChecksumDict end_getSliceChecksums(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::Ice::SliceChecksumDict getSliceChecksums(const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getSliceChecksums(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    
    ::IceInternal::ProxyHandle<Admin> ice_context(const ::Ice::Context& __context) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Admin*>(_Base::ice_context(__context).get());
    #else
        return dynamic_cast<Admin*>(::IceProxy::Ice::Object::ice_context(__context).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Admin> ice_adapterId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Admin*>(_Base::ice_adapterId(__id).get());
    #else
        return dynamic_cast<Admin*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Admin> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Admin*>(_Base::ice_endpoints(__endpoints).get());
    #else
        return dynamic_cast<Admin*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Admin> ice_locatorCacheTimeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Admin*>(_Base::ice_locatorCacheTimeout(__timeout).get());
    #else
        return dynamic_cast<Admin*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Admin> ice_connectionCached(bool __cached) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Admin*>(_Base::ice_connectionCached(__cached).get());
    #else
        return dynamic_cast<Admin*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Admin> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Admin*>(_Base::ice_endpointSelection(__est).get());
    #else
        return dynamic_cast<Admin*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Admin> ice_secure(bool __secure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Admin*>(_Base::ice_secure(__secure).get());
    #else
        return dynamic_cast<Admin*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Admin> ice_preferSecure(bool __preferSecure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Admin*>(_Base::ice_preferSecure(__preferSecure).get());
    #else
        return dynamic_cast<Admin*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Admin> ice_router(const ::Ice::RouterPrx& __router) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Admin*>(_Base::ice_router(__router).get());
    #else
        return dynamic_cast<Admin*>(::IceProxy::Ice::Object::ice_router(__router).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Admin> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Admin*>(_Base::ice_locator(__locator).get());
    #else
        return dynamic_cast<Admin*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Admin> ice_collocationOptimized(bool __co) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Admin*>(_Base::ice_collocationOptimized(__co).get());
    #else
        return dynamic_cast<Admin*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Admin> ice_twoway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Admin*>(_Base::ice_twoway().get());
    #else
        return dynamic_cast<Admin*>(::IceProxy::Ice::Object::ice_twoway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Admin> ice_oneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Admin*>(_Base::ice_oneway().get());
    #else
        return dynamic_cast<Admin*>(::IceProxy::Ice::Object::ice_oneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Admin> ice_batchOneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Admin*>(_Base::ice_batchOneway().get());
    #else
        return dynamic_cast<Admin*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Admin> ice_datagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Admin*>(_Base::ice_datagram().get());
    #else
        return dynamic_cast<Admin*>(::IceProxy::Ice::Object::ice_datagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Admin> ice_batchDatagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Admin*>(_Base::ice_batchDatagram().get());
    #else
        return dynamic_cast<Admin*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Admin> ice_compress(bool __compress) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Admin*>(_Base::ice_compress(__compress).get());
    #else
        return dynamic_cast<Admin*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Admin> ice_timeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Admin*>(_Base::ice_timeout(__timeout).get());
    #else
        return dynamic_cast<Admin*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Admin> ice_connectionId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Admin*>(_Base::ice_connectionId(__id).get());
    #else
        return dynamic_cast<Admin*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    #endif
    }
    
    ICE_GRID_API static const ::std::string& ice_staticId();

private: 

    ICE_GRID_API virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
    ICE_GRID_API virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
    ICE_GRID_API virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class FileIterator : virtual public ::IceProxy::Ice::Object
{
public:

    bool read(::Ice::Int size, ::Ice::StringSeq& lines)
    {
        return read(size, lines, 0);
    }
    bool read(::Ice::Int size, ::Ice::StringSeq& lines, const ::Ice::Context& __ctx)
    {
        return read(size, lines, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_read(::Ice::Int size)
    {
        return begin_read(size, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_read(::Ice::Int size, const ::Ice::Context& __ctx)
    {
        return begin_read(size, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_read(::Ice::Int size, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_read(size, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_read(::Ice::Int size, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_read(size, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_read(::Ice::Int size, const ::IceGrid::Callback_FileIterator_readPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_read(size, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_read(::Ice::Int size, const ::Ice::Context& __ctx, const ::IceGrid::Callback_FileIterator_readPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_read(size, &__ctx, __del, __cookie);
    }

    ICE_GRID_API bool end_read(::Ice::StringSeq& lines, const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API bool read(::Ice::Int, ::Ice::StringSeq&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_read(::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    void destroy()
    {
        destroy(0);
    }
    void destroy(const ::Ice::Context& __ctx)
    {
        destroy(&__ctx);
    }

    ::Ice::AsyncResultPtr begin_destroy()
    {
        return begin_destroy(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_destroy(const ::Ice::Context& __ctx)
    {
        return begin_destroy(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_destroy(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_destroy(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_destroy(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_destroy(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_destroy(const ::IceGrid::Callback_FileIterator_destroyPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_destroy(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_destroy(const ::Ice::Context& __ctx, const ::IceGrid::Callback_FileIterator_destroyPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_destroy(&__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_destroy(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void destroy(const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_destroy(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    
    ::IceInternal::ProxyHandle<FileIterator> ice_context(const ::Ice::Context& __context) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FileIterator*>(_Base::ice_context(__context).get());
    #else
        return dynamic_cast<FileIterator*>(::IceProxy::Ice::Object::ice_context(__context).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FileIterator> ice_adapterId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FileIterator*>(_Base::ice_adapterId(__id).get());
    #else
        return dynamic_cast<FileIterator*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FileIterator> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FileIterator*>(_Base::ice_endpoints(__endpoints).get());
    #else
        return dynamic_cast<FileIterator*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FileIterator> ice_locatorCacheTimeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FileIterator*>(_Base::ice_locatorCacheTimeout(__timeout).get());
    #else
        return dynamic_cast<FileIterator*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FileIterator> ice_connectionCached(bool __cached) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FileIterator*>(_Base::ice_connectionCached(__cached).get());
    #else
        return dynamic_cast<FileIterator*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FileIterator> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FileIterator*>(_Base::ice_endpointSelection(__est).get());
    #else
        return dynamic_cast<FileIterator*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FileIterator> ice_secure(bool __secure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FileIterator*>(_Base::ice_secure(__secure).get());
    #else
        return dynamic_cast<FileIterator*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FileIterator> ice_preferSecure(bool __preferSecure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FileIterator*>(_Base::ice_preferSecure(__preferSecure).get());
    #else
        return dynamic_cast<FileIterator*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FileIterator> ice_router(const ::Ice::RouterPrx& __router) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FileIterator*>(_Base::ice_router(__router).get());
    #else
        return dynamic_cast<FileIterator*>(::IceProxy::Ice::Object::ice_router(__router).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FileIterator> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FileIterator*>(_Base::ice_locator(__locator).get());
    #else
        return dynamic_cast<FileIterator*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FileIterator> ice_collocationOptimized(bool __co) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FileIterator*>(_Base::ice_collocationOptimized(__co).get());
    #else
        return dynamic_cast<FileIterator*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FileIterator> ice_twoway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FileIterator*>(_Base::ice_twoway().get());
    #else
        return dynamic_cast<FileIterator*>(::IceProxy::Ice::Object::ice_twoway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FileIterator> ice_oneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FileIterator*>(_Base::ice_oneway().get());
    #else
        return dynamic_cast<FileIterator*>(::IceProxy::Ice::Object::ice_oneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FileIterator> ice_batchOneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FileIterator*>(_Base::ice_batchOneway().get());
    #else
        return dynamic_cast<FileIterator*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FileIterator> ice_datagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FileIterator*>(_Base::ice_datagram().get());
    #else
        return dynamic_cast<FileIterator*>(::IceProxy::Ice::Object::ice_datagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FileIterator> ice_batchDatagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FileIterator*>(_Base::ice_batchDatagram().get());
    #else
        return dynamic_cast<FileIterator*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FileIterator> ice_compress(bool __compress) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FileIterator*>(_Base::ice_compress(__compress).get());
    #else
        return dynamic_cast<FileIterator*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FileIterator> ice_timeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FileIterator*>(_Base::ice_timeout(__timeout).get());
    #else
        return dynamic_cast<FileIterator*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FileIterator> ice_connectionId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FileIterator*>(_Base::ice_connectionId(__id).get());
    #else
        return dynamic_cast<FileIterator*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    #endif
    }
    
    ICE_GRID_API static const ::std::string& ice_staticId();

private: 

    ICE_GRID_API virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
    ICE_GRID_API virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
    ICE_GRID_API virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class AdminSession : virtual public ::IceProxy::Glacier2::Session
{
public:

    void keepAlive()
    {
        keepAlive(0);
    }
    void keepAlive(const ::Ice::Context& __ctx)
    {
        keepAlive(&__ctx);
    }

    ::Ice::AsyncResultPtr begin_keepAlive()
    {
        return begin_keepAlive(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_keepAlive(const ::Ice::Context& __ctx)
    {
        return begin_keepAlive(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_keepAlive(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_keepAlive(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_keepAlive(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_keepAlive(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_keepAlive(const ::IceGrid::Callback_AdminSession_keepAlivePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_keepAlive(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_keepAlive(const ::Ice::Context& __ctx, const ::IceGrid::Callback_AdminSession_keepAlivePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_keepAlive(&__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_keepAlive(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void keepAlive(const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_keepAlive(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::IceGrid::AdminPrx getAdmin()
    {
        return getAdmin(0);
    }
    ::IceGrid::AdminPrx getAdmin(const ::Ice::Context& __ctx)
    {
        return getAdmin(&__ctx);
    }

    ::Ice::AsyncResultPtr begin_getAdmin()
    {
        return begin_getAdmin(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getAdmin(const ::Ice::Context& __ctx)
    {
        return begin_getAdmin(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getAdmin(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAdmin(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAdmin(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAdmin(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAdmin(const ::IceGrid::Callback_AdminSession_getAdminPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAdmin(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAdmin(const ::Ice::Context& __ctx, const ::IceGrid::Callback_AdminSession_getAdminPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAdmin(&__ctx, __del, __cookie);
    }

    ICE_GRID_API ::IceGrid::AdminPrx end_getAdmin(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::IceGrid::AdminPrx getAdmin(const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getAdmin(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::Ice::ObjectPrx getAdminCallbackTemplate()
    {
        return getAdminCallbackTemplate(0);
    }
    ::Ice::ObjectPrx getAdminCallbackTemplate(const ::Ice::Context& __ctx)
    {
        return getAdminCallbackTemplate(&__ctx);
    }

    ::Ice::AsyncResultPtr begin_getAdminCallbackTemplate()
    {
        return begin_getAdminCallbackTemplate(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getAdminCallbackTemplate(const ::Ice::Context& __ctx)
    {
        return begin_getAdminCallbackTemplate(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getAdminCallbackTemplate(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAdminCallbackTemplate(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAdminCallbackTemplate(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAdminCallbackTemplate(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAdminCallbackTemplate(const ::IceGrid::Callback_AdminSession_getAdminCallbackTemplatePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAdminCallbackTemplate(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getAdminCallbackTemplate(const ::Ice::Context& __ctx, const ::IceGrid::Callback_AdminSession_getAdminCallbackTemplatePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getAdminCallbackTemplate(&__ctx, __del, __cookie);
    }

    ICE_GRID_API ::Ice::ObjectPrx end_getAdminCallbackTemplate(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::Ice::ObjectPrx getAdminCallbackTemplate(const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getAdminCallbackTemplate(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    void setObservers(const ::IceGrid::RegistryObserverPrx& registryObs, const ::IceGrid::NodeObserverPrx& nodeObs, const ::IceGrid::ApplicationObserverPrx& appObs, const ::IceGrid::AdapterObserverPrx& adptObs, const ::IceGrid::ObjectObserverPrx& objObs)
    {
        setObservers(registryObs, nodeObs, appObs, adptObs, objObs, 0);
    }
    void setObservers(const ::IceGrid::RegistryObserverPrx& registryObs, const ::IceGrid::NodeObserverPrx& nodeObs, const ::IceGrid::ApplicationObserverPrx& appObs, const ::IceGrid::AdapterObserverPrx& adptObs, const ::IceGrid::ObjectObserverPrx& objObs, const ::Ice::Context& __ctx)
    {
        setObservers(registryObs, nodeObs, appObs, adptObs, objObs, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_setObservers(const ::IceGrid::RegistryObserverPrx& registryObs, const ::IceGrid::NodeObserverPrx& nodeObs, const ::IceGrid::ApplicationObserverPrx& appObs, const ::IceGrid::AdapterObserverPrx& adptObs, const ::IceGrid::ObjectObserverPrx& objObs)
    {
        return begin_setObservers(registryObs, nodeObs, appObs, adptObs, objObs, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_setObservers(const ::IceGrid::RegistryObserverPrx& registryObs, const ::IceGrid::NodeObserverPrx& nodeObs, const ::IceGrid::ApplicationObserverPrx& appObs, const ::IceGrid::AdapterObserverPrx& adptObs, const ::IceGrid::ObjectObserverPrx& objObs, const ::Ice::Context& __ctx)
    {
        return begin_setObservers(registryObs, nodeObs, appObs, adptObs, objObs, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_setObservers(const ::IceGrid::RegistryObserverPrx& registryObs, const ::IceGrid::NodeObserverPrx& nodeObs, const ::IceGrid::ApplicationObserverPrx& appObs, const ::IceGrid::AdapterObserverPrx& adptObs, const ::IceGrid::ObjectObserverPrx& objObs, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_setObservers(registryObs, nodeObs, appObs, adptObs, objObs, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_setObservers(const ::IceGrid::RegistryObserverPrx& registryObs, const ::IceGrid::NodeObserverPrx& nodeObs, const ::IceGrid::ApplicationObserverPrx& appObs, const ::IceGrid::AdapterObserverPrx& adptObs, const ::IceGrid::ObjectObserverPrx& objObs, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_setObservers(registryObs, nodeObs, appObs, adptObs, objObs, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_setObservers(const ::IceGrid::RegistryObserverPrx& registryObs, const ::IceGrid::NodeObserverPrx& nodeObs, const ::IceGrid::ApplicationObserverPrx& appObs, const ::IceGrid::AdapterObserverPrx& adptObs, const ::IceGrid::ObjectObserverPrx& objObs, const ::IceGrid::Callback_AdminSession_setObserversPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_setObservers(registryObs, nodeObs, appObs, adptObs, objObs, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_setObservers(const ::IceGrid::RegistryObserverPrx& registryObs, const ::IceGrid::NodeObserverPrx& nodeObs, const ::IceGrid::ApplicationObserverPrx& appObs, const ::IceGrid::AdapterObserverPrx& adptObs, const ::IceGrid::ObjectObserverPrx& objObs, const ::Ice::Context& __ctx, const ::IceGrid::Callback_AdminSession_setObserversPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_setObservers(registryObs, nodeObs, appObs, adptObs, objObs, &__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_setObservers(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void setObservers(const ::IceGrid::RegistryObserverPrx&, const ::IceGrid::NodeObserverPrx&, const ::IceGrid::ApplicationObserverPrx&, const ::IceGrid::AdapterObserverPrx&, const ::IceGrid::ObjectObserverPrx&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_setObservers(const ::IceGrid::RegistryObserverPrx&, const ::IceGrid::NodeObserverPrx&, const ::IceGrid::ApplicationObserverPrx&, const ::IceGrid::AdapterObserverPrx&, const ::IceGrid::ObjectObserverPrx&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    void setObserversByIdentity(const ::Ice::Identity& registryObs, const ::Ice::Identity& nodeObs, const ::Ice::Identity& appObs, const ::Ice::Identity& adptObs, const ::Ice::Identity& objObs)
    {
        setObserversByIdentity(registryObs, nodeObs, appObs, adptObs, objObs, 0);
    }
    void setObserversByIdentity(const ::Ice::Identity& registryObs, const ::Ice::Identity& nodeObs, const ::Ice::Identity& appObs, const ::Ice::Identity& adptObs, const ::Ice::Identity& objObs, const ::Ice::Context& __ctx)
    {
        setObserversByIdentity(registryObs, nodeObs, appObs, adptObs, objObs, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_setObserversByIdentity(const ::Ice::Identity& registryObs, const ::Ice::Identity& nodeObs, const ::Ice::Identity& appObs, const ::Ice::Identity& adptObs, const ::Ice::Identity& objObs)
    {
        return begin_setObserversByIdentity(registryObs, nodeObs, appObs, adptObs, objObs, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_setObserversByIdentity(const ::Ice::Identity& registryObs, const ::Ice::Identity& nodeObs, const ::Ice::Identity& appObs, const ::Ice::Identity& adptObs, const ::Ice::Identity& objObs, const ::Ice::Context& __ctx)
    {
        return begin_setObserversByIdentity(registryObs, nodeObs, appObs, adptObs, objObs, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_setObserversByIdentity(const ::Ice::Identity& registryObs, const ::Ice::Identity& nodeObs, const ::Ice::Identity& appObs, const ::Ice::Identity& adptObs, const ::Ice::Identity& objObs, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_setObserversByIdentity(registryObs, nodeObs, appObs, adptObs, objObs, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_setObserversByIdentity(const ::Ice::Identity& registryObs, const ::Ice::Identity& nodeObs, const ::Ice::Identity& appObs, const ::Ice::Identity& adptObs, const ::Ice::Identity& objObs, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_setObserversByIdentity(registryObs, nodeObs, appObs, adptObs, objObs, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_setObserversByIdentity(const ::Ice::Identity& registryObs, const ::Ice::Identity& nodeObs, const ::Ice::Identity& appObs, const ::Ice::Identity& adptObs, const ::Ice::Identity& objObs, const ::IceGrid::Callback_AdminSession_setObserversByIdentityPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_setObserversByIdentity(registryObs, nodeObs, appObs, adptObs, objObs, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_setObserversByIdentity(const ::Ice::Identity& registryObs, const ::Ice::Identity& nodeObs, const ::Ice::Identity& appObs, const ::Ice::Identity& adptObs, const ::Ice::Identity& objObs, const ::Ice::Context& __ctx, const ::IceGrid::Callback_AdminSession_setObserversByIdentityPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_setObserversByIdentity(registryObs, nodeObs, appObs, adptObs, objObs, &__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_setObserversByIdentity(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void setObserversByIdentity(const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_setObserversByIdentity(const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::Ice::Int startUpdate()
    {
        return startUpdate(0);
    }
    ::Ice::Int startUpdate(const ::Ice::Context& __ctx)
    {
        return startUpdate(&__ctx);
    }

    ::Ice::AsyncResultPtr begin_startUpdate()
    {
        return begin_startUpdate(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_startUpdate(const ::Ice::Context& __ctx)
    {
        return begin_startUpdate(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_startUpdate(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_startUpdate(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_startUpdate(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_startUpdate(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_startUpdate(const ::IceGrid::Callback_AdminSession_startUpdatePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_startUpdate(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_startUpdate(const ::Ice::Context& __ctx, const ::IceGrid::Callback_AdminSession_startUpdatePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_startUpdate(&__ctx, __del, __cookie);
    }

    ICE_GRID_API ::Ice::Int end_startUpdate(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::Ice::Int startUpdate(const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_startUpdate(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    void finishUpdate()
    {
        finishUpdate(0);
    }
    void finishUpdate(const ::Ice::Context& __ctx)
    {
        finishUpdate(&__ctx);
    }

    ::Ice::AsyncResultPtr begin_finishUpdate()
    {
        return begin_finishUpdate(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_finishUpdate(const ::Ice::Context& __ctx)
    {
        return begin_finishUpdate(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_finishUpdate(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_finishUpdate(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_finishUpdate(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_finishUpdate(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_finishUpdate(const ::IceGrid::Callback_AdminSession_finishUpdatePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_finishUpdate(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_finishUpdate(const ::Ice::Context& __ctx, const ::IceGrid::Callback_AdminSession_finishUpdatePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_finishUpdate(&__ctx, __del, __cookie);
    }

    ICE_GRID_API void end_finishUpdate(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API void finishUpdate(const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_finishUpdate(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::std::string getReplicaName()
    {
        return getReplicaName(0);
    }
    ::std::string getReplicaName(const ::Ice::Context& __ctx)
    {
        return getReplicaName(&__ctx);
    }

    ::Ice::AsyncResultPtr begin_getReplicaName()
    {
        return begin_getReplicaName(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getReplicaName(const ::Ice::Context& __ctx)
    {
        return begin_getReplicaName(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getReplicaName(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getReplicaName(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getReplicaName(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getReplicaName(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getReplicaName(const ::IceGrid::Callback_AdminSession_getReplicaNamePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getReplicaName(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_getReplicaName(const ::Ice::Context& __ctx, const ::IceGrid::Callback_AdminSession_getReplicaNamePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_getReplicaName(&__ctx, __del, __cookie);
    }

    ICE_GRID_API ::std::string end_getReplicaName(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::std::string getReplicaName(const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_getReplicaName(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::IceGrid::FileIteratorPrx openServerLog(const ::std::string& id, const ::std::string& path, ::Ice::Int count)
    {
        return openServerLog(id, path, count, 0);
    }
    ::IceGrid::FileIteratorPrx openServerLog(const ::std::string& id, const ::std::string& path, ::Ice::Int count, const ::Ice::Context& __ctx)
    {
        return openServerLog(id, path, count, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_openServerLog(const ::std::string& id, const ::std::string& path, ::Ice::Int count)
    {
        return begin_openServerLog(id, path, count, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_openServerLog(const ::std::string& id, const ::std::string& path, ::Ice::Int count, const ::Ice::Context& __ctx)
    {
        return begin_openServerLog(id, path, count, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_openServerLog(const ::std::string& id, const ::std::string& path, ::Ice::Int count, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openServerLog(id, path, count, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_openServerLog(const ::std::string& id, const ::std::string& path, ::Ice::Int count, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openServerLog(id, path, count, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_openServerLog(const ::std::string& id, const ::std::string& path, ::Ice::Int count, const ::IceGrid::Callback_AdminSession_openServerLogPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openServerLog(id, path, count, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_openServerLog(const ::std::string& id, const ::std::string& path, ::Ice::Int count, const ::Ice::Context& __ctx, const ::IceGrid::Callback_AdminSession_openServerLogPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openServerLog(id, path, count, &__ctx, __del, __cookie);
    }

    ICE_GRID_API ::IceGrid::FileIteratorPrx end_openServerLog(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::IceGrid::FileIteratorPrx openServerLog(const ::std::string&, const ::std::string&, ::Ice::Int, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_openServerLog(const ::std::string&, const ::std::string&, ::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::IceGrid::FileIteratorPrx openServerStdErr(const ::std::string& id, ::Ice::Int count)
    {
        return openServerStdErr(id, count, 0);
    }
    ::IceGrid::FileIteratorPrx openServerStdErr(const ::std::string& id, ::Ice::Int count, const ::Ice::Context& __ctx)
    {
        return openServerStdErr(id, count, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_openServerStdErr(const ::std::string& id, ::Ice::Int count)
    {
        return begin_openServerStdErr(id, count, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_openServerStdErr(const ::std::string& id, ::Ice::Int count, const ::Ice::Context& __ctx)
    {
        return begin_openServerStdErr(id, count, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_openServerStdErr(const ::std::string& id, ::Ice::Int count, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openServerStdErr(id, count, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_openServerStdErr(const ::std::string& id, ::Ice::Int count, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openServerStdErr(id, count, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_openServerStdErr(const ::std::string& id, ::Ice::Int count, const ::IceGrid::Callback_AdminSession_openServerStdErrPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openServerStdErr(id, count, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_openServerStdErr(const ::std::string& id, ::Ice::Int count, const ::Ice::Context& __ctx, const ::IceGrid::Callback_AdminSession_openServerStdErrPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openServerStdErr(id, count, &__ctx, __del, __cookie);
    }

    ICE_GRID_API ::IceGrid::FileIteratorPrx end_openServerStdErr(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::IceGrid::FileIteratorPrx openServerStdErr(const ::std::string&, ::Ice::Int, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_openServerStdErr(const ::std::string&, ::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::IceGrid::FileIteratorPrx openServerStdOut(const ::std::string& id, ::Ice::Int count)
    {
        return openServerStdOut(id, count, 0);
    }
    ::IceGrid::FileIteratorPrx openServerStdOut(const ::std::string& id, ::Ice::Int count, const ::Ice::Context& __ctx)
    {
        return openServerStdOut(id, count, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_openServerStdOut(const ::std::string& id, ::Ice::Int count)
    {
        return begin_openServerStdOut(id, count, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_openServerStdOut(const ::std::string& id, ::Ice::Int count, const ::Ice::Context& __ctx)
    {
        return begin_openServerStdOut(id, count, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_openServerStdOut(const ::std::string& id, ::Ice::Int count, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openServerStdOut(id, count, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_openServerStdOut(const ::std::string& id, ::Ice::Int count, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openServerStdOut(id, count, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_openServerStdOut(const ::std::string& id, ::Ice::Int count, const ::IceGrid::Callback_AdminSession_openServerStdOutPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openServerStdOut(id, count, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_openServerStdOut(const ::std::string& id, ::Ice::Int count, const ::Ice::Context& __ctx, const ::IceGrid::Callback_AdminSession_openServerStdOutPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openServerStdOut(id, count, &__ctx, __del, __cookie);
    }

    ICE_GRID_API ::IceGrid::FileIteratorPrx end_openServerStdOut(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::IceGrid::FileIteratorPrx openServerStdOut(const ::std::string&, ::Ice::Int, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_openServerStdOut(const ::std::string&, ::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::IceGrid::FileIteratorPrx openNodeStdErr(const ::std::string& name, ::Ice::Int count)
    {
        return openNodeStdErr(name, count, 0);
    }
    ::IceGrid::FileIteratorPrx openNodeStdErr(const ::std::string& name, ::Ice::Int count, const ::Ice::Context& __ctx)
    {
        return openNodeStdErr(name, count, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_openNodeStdErr(const ::std::string& name, ::Ice::Int count)
    {
        return begin_openNodeStdErr(name, count, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_openNodeStdErr(const ::std::string& name, ::Ice::Int count, const ::Ice::Context& __ctx)
    {
        return begin_openNodeStdErr(name, count, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_openNodeStdErr(const ::std::string& name, ::Ice::Int count, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openNodeStdErr(name, count, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_openNodeStdErr(const ::std::string& name, ::Ice::Int count, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openNodeStdErr(name, count, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_openNodeStdErr(const ::std::string& name, ::Ice::Int count, const ::IceGrid::Callback_AdminSession_openNodeStdErrPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openNodeStdErr(name, count, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_openNodeStdErr(const ::std::string& name, ::Ice::Int count, const ::Ice::Context& __ctx, const ::IceGrid::Callback_AdminSession_openNodeStdErrPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openNodeStdErr(name, count, &__ctx, __del, __cookie);
    }

    ICE_GRID_API ::IceGrid::FileIteratorPrx end_openNodeStdErr(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::IceGrid::FileIteratorPrx openNodeStdErr(const ::std::string&, ::Ice::Int, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_openNodeStdErr(const ::std::string&, ::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::IceGrid::FileIteratorPrx openNodeStdOut(const ::std::string& name, ::Ice::Int count)
    {
        return openNodeStdOut(name, count, 0);
    }
    ::IceGrid::FileIteratorPrx openNodeStdOut(const ::std::string& name, ::Ice::Int count, const ::Ice::Context& __ctx)
    {
        return openNodeStdOut(name, count, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_openNodeStdOut(const ::std::string& name, ::Ice::Int count)
    {
        return begin_openNodeStdOut(name, count, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_openNodeStdOut(const ::std::string& name, ::Ice::Int count, const ::Ice::Context& __ctx)
    {
        return begin_openNodeStdOut(name, count, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_openNodeStdOut(const ::std::string& name, ::Ice::Int count, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openNodeStdOut(name, count, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_openNodeStdOut(const ::std::string& name, ::Ice::Int count, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openNodeStdOut(name, count, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_openNodeStdOut(const ::std::string& name, ::Ice::Int count, const ::IceGrid::Callback_AdminSession_openNodeStdOutPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openNodeStdOut(name, count, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_openNodeStdOut(const ::std::string& name, ::Ice::Int count, const ::Ice::Context& __ctx, const ::IceGrid::Callback_AdminSession_openNodeStdOutPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openNodeStdOut(name, count, &__ctx, __del, __cookie);
    }

    ICE_GRID_API ::IceGrid::FileIteratorPrx end_openNodeStdOut(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::IceGrid::FileIteratorPrx openNodeStdOut(const ::std::string&, ::Ice::Int, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_openNodeStdOut(const ::std::string&, ::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::IceGrid::FileIteratorPrx openRegistryStdErr(const ::std::string& name, ::Ice::Int count)
    {
        return openRegistryStdErr(name, count, 0);
    }
    ::IceGrid::FileIteratorPrx openRegistryStdErr(const ::std::string& name, ::Ice::Int count, const ::Ice::Context& __ctx)
    {
        return openRegistryStdErr(name, count, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_openRegistryStdErr(const ::std::string& name, ::Ice::Int count)
    {
        return begin_openRegistryStdErr(name, count, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_openRegistryStdErr(const ::std::string& name, ::Ice::Int count, const ::Ice::Context& __ctx)
    {
        return begin_openRegistryStdErr(name, count, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_openRegistryStdErr(const ::std::string& name, ::Ice::Int count, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openRegistryStdErr(name, count, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_openRegistryStdErr(const ::std::string& name, ::Ice::Int count, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openRegistryStdErr(name, count, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_openRegistryStdErr(const ::std::string& name, ::Ice::Int count, const ::IceGrid::Callback_AdminSession_openRegistryStdErrPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openRegistryStdErr(name, count, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_openRegistryStdErr(const ::std::string& name, ::Ice::Int count, const ::Ice::Context& __ctx, const ::IceGrid::Callback_AdminSession_openRegistryStdErrPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openRegistryStdErr(name, count, &__ctx, __del, __cookie);
    }

    ICE_GRID_API ::IceGrid::FileIteratorPrx end_openRegistryStdErr(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::IceGrid::FileIteratorPrx openRegistryStdErr(const ::std::string&, ::Ice::Int, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_openRegistryStdErr(const ::std::string&, ::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:

    ::IceGrid::FileIteratorPrx openRegistryStdOut(const ::std::string& name, ::Ice::Int count)
    {
        return openRegistryStdOut(name, count, 0);
    }
    ::IceGrid::FileIteratorPrx openRegistryStdOut(const ::std::string& name, ::Ice::Int count, const ::Ice::Context& __ctx)
    {
        return openRegistryStdOut(name, count, &__ctx);
    }

    ::Ice::AsyncResultPtr begin_openRegistryStdOut(const ::std::string& name, ::Ice::Int count)
    {
        return begin_openRegistryStdOut(name, count, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_openRegistryStdOut(const ::std::string& name, ::Ice::Int count, const ::Ice::Context& __ctx)
    {
        return begin_openRegistryStdOut(name, count, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_openRegistryStdOut(const ::std::string& name, ::Ice::Int count, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openRegistryStdOut(name, count, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_openRegistryStdOut(const ::std::string& name, ::Ice::Int count, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openRegistryStdOut(name, count, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_openRegistryStdOut(const ::std::string& name, ::Ice::Int count, const ::IceGrid::Callback_AdminSession_openRegistryStdOutPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openRegistryStdOut(name, count, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_openRegistryStdOut(const ::std::string& name, ::Ice::Int count, const ::Ice::Context& __ctx, const ::IceGrid::Callback_AdminSession_openRegistryStdOutPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_openRegistryStdOut(name, count, &__ctx, __del, __cookie);
    }

    ICE_GRID_API ::IceGrid::FileIteratorPrx end_openRegistryStdOut(const ::Ice::AsyncResultPtr&);
    
private:

    ICE_GRID_API ::IceGrid::FileIteratorPrx openRegistryStdOut(const ::std::string&, ::Ice::Int, const ::Ice::Context*);
    ICE_GRID_API ::Ice::AsyncResultPtr begin_openRegistryStdOut(const ::std::string&, ::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    
    ::IceInternal::ProxyHandle<AdminSession> ice_context(const ::Ice::Context& __context) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<AdminSession*>(_Base::ice_context(__context).get());
    #else
        return dynamic_cast<AdminSession*>(::IceProxy::Ice::Object::ice_context(__context).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<AdminSession> ice_adapterId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<AdminSession*>(_Base::ice_adapterId(__id).get());
    #else
        return dynamic_cast<AdminSession*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<AdminSession> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<AdminSession*>(_Base::ice_endpoints(__endpoints).get());
    #else
        return dynamic_cast<AdminSession*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<AdminSession> ice_locatorCacheTimeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<AdminSession*>(_Base::ice_locatorCacheTimeout(__timeout).get());
    #else
        return dynamic_cast<AdminSession*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<AdminSession> ice_connectionCached(bool __cached) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<AdminSession*>(_Base::ice_connectionCached(__cached).get());
    #else
        return dynamic_cast<AdminSession*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<AdminSession> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<AdminSession*>(_Base::ice_endpointSelection(__est).get());
    #else
        return dynamic_cast<AdminSession*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<AdminSession> ice_secure(bool __secure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<AdminSession*>(_Base::ice_secure(__secure).get());
    #else
        return dynamic_cast<AdminSession*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<AdminSession> ice_preferSecure(bool __preferSecure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<AdminSession*>(_Base::ice_preferSecure(__preferSecure).get());
    #else
        return dynamic_cast<AdminSession*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<AdminSession> ice_router(const ::Ice::RouterPrx& __router) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<AdminSession*>(_Base::ice_router(__router).get());
    #else
        return dynamic_cast<AdminSession*>(::IceProxy::Ice::Object::ice_router(__router).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<AdminSession> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<AdminSession*>(_Base::ice_locator(__locator).get());
    #else
        return dynamic_cast<AdminSession*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<AdminSession> ice_collocationOptimized(bool __co) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<AdminSession*>(_Base::ice_collocationOptimized(__co).get());
    #else
        return dynamic_cast<AdminSession*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<AdminSession> ice_twoway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<AdminSession*>(_Base::ice_twoway().get());
    #else
        return dynamic_cast<AdminSession*>(::IceProxy::Ice::Object::ice_twoway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<AdminSession> ice_oneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<AdminSession*>(_Base::ice_oneway().get());
    #else
        return dynamic_cast<AdminSession*>(::IceProxy::Ice::Object::ice_oneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<AdminSession> ice_batchOneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<AdminSession*>(_Base::ice_batchOneway().get());
    #else
        return dynamic_cast<AdminSession*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<AdminSession> ice_datagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<AdminSession*>(_Base::ice_datagram().get());
    #else
        return dynamic_cast<AdminSession*>(::IceProxy::Ice::Object::ice_datagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<AdminSession> ice_batchDatagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<AdminSession*>(_Base::ice_batchDatagram().get());
    #else
        return dynamic_cast<AdminSession*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<AdminSession> ice_compress(bool __compress) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<AdminSession*>(_Base::ice_compress(__compress).get());
    #else
        return dynamic_cast<AdminSession*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<AdminSession> ice_timeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<AdminSession*>(_Base::ice_timeout(__timeout).get());
    #else
        return dynamic_cast<AdminSession*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<AdminSession> ice_connectionId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<AdminSession*>(_Base::ice_connectionId(__id).get());
    #else
        return dynamic_cast<AdminSession*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    #endif
    }
    
    ICE_GRID_API static const ::std::string& ice_staticId();

private: 

    ICE_GRID_API virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
    ICE_GRID_API virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
    ICE_GRID_API virtual ::IceProxy::Ice::Object* __newInstance() const;
};

}

}

namespace IceDelegate
{

namespace IceGrid
{

class ICE_GRID_API Admin : virtual public ::IceDelegate::Ice::Object
{
public:

    virtual void addApplication(const ::IceGrid::ApplicationDescriptor&, const ::Ice::Context*) = 0;

    virtual void syncApplication(const ::IceGrid::ApplicationDescriptor&, const ::Ice::Context*) = 0;

    virtual void updateApplication(const ::IceGrid::ApplicationUpdateDescriptor&, const ::Ice::Context*) = 0;

    virtual void removeApplication(const ::std::string&, const ::Ice::Context*) = 0;

    virtual void instantiateServer(const ::std::string&, const ::std::string&, const ::IceGrid::ServerInstanceDescriptor&, const ::Ice::Context*) = 0;

    virtual void patchApplication(const ::std::string&, bool, const ::Ice::Context*) = 0;

    virtual ::IceGrid::ApplicationInfo getApplicationInfo(const ::std::string&, const ::Ice::Context*) = 0;

    virtual ::IceGrid::ApplicationDescriptor getDefaultApplicationDescriptor(const ::Ice::Context*) = 0;

    virtual ::Ice::StringSeq getAllApplicationNames(const ::Ice::Context*) = 0;

    virtual ::IceGrid::ServerInfo getServerInfo(const ::std::string&, const ::Ice::Context*) = 0;

    virtual ::IceGrid::ServerState getServerState(const ::std::string&, const ::Ice::Context*) = 0;

    virtual ::Ice::Int getServerPid(const ::std::string&, const ::Ice::Context*) = 0;

    virtual ::std::string getServerAdminCategory(const ::Ice::Context*) = 0;

    virtual ::Ice::ObjectPrx getServerAdmin(const ::std::string&, const ::Ice::Context*) = 0;

    virtual void enableServer(const ::std::string&, bool, const ::Ice::Context*) = 0;

    virtual bool isServerEnabled(const ::std::string&, const ::Ice::Context*) = 0;

    virtual void startServer(const ::std::string&, const ::Ice::Context*) = 0;

    virtual void stopServer(const ::std::string&, const ::Ice::Context*) = 0;

    virtual void patchServer(const ::std::string&, bool, const ::Ice::Context*) = 0;

    virtual void sendSignal(const ::std::string&, const ::std::string&, const ::Ice::Context*) = 0;

    virtual void writeMessage(const ::std::string&, const ::std::string&, ::Ice::Int, const ::Ice::Context*) = 0;

    virtual ::Ice::StringSeq getAllServerIds(const ::Ice::Context*) = 0;

    virtual ::IceGrid::AdapterInfoSeq getAdapterInfo(const ::std::string&, const ::Ice::Context*) = 0;

    virtual void removeAdapter(const ::std::string&, const ::Ice::Context*) = 0;

    virtual ::Ice::StringSeq getAllAdapterIds(const ::Ice::Context*) = 0;

    virtual void addObject(const ::Ice::ObjectPrx&, const ::Ice::Context*) = 0;

    virtual void updateObject(const ::Ice::ObjectPrx&, const ::Ice::Context*) = 0;

    virtual void addObjectWithType(const ::Ice::ObjectPrx&, const ::std::string&, const ::Ice::Context*) = 0;

    virtual void removeObject(const ::Ice::Identity&, const ::Ice::Context*) = 0;

    virtual ::IceGrid::ObjectInfo getObjectInfo(const ::Ice::Identity&, const ::Ice::Context*) = 0;

    virtual ::IceGrid::ObjectInfoSeq getObjectInfosByType(const ::std::string&, const ::Ice::Context*) = 0;

    virtual ::IceGrid::ObjectInfoSeq getAllObjectInfos(const ::std::string&, const ::Ice::Context*) = 0;

    virtual bool pingNode(const ::std::string&, const ::Ice::Context*) = 0;

    virtual ::IceGrid::LoadInfo getNodeLoad(const ::std::string&, const ::Ice::Context*) = 0;

    virtual ::IceGrid::NodeInfo getNodeInfo(const ::std::string&, const ::Ice::Context*) = 0;

    virtual ::Ice::Int getNodeProcessorSocketCount(const ::std::string&, const ::Ice::Context*) = 0;

    virtual void shutdownNode(const ::std::string&, const ::Ice::Context*) = 0;

    virtual ::std::string getNodeHostname(const ::std::string&, const ::Ice::Context*) = 0;

    virtual ::Ice::StringSeq getAllNodeNames(const ::Ice::Context*) = 0;

    virtual bool pingRegistry(const ::std::string&, const ::Ice::Context*) = 0;

    virtual ::IceGrid::RegistryInfo getRegistryInfo(const ::std::string&, const ::Ice::Context*) = 0;

    virtual void shutdownRegistry(const ::std::string&, const ::Ice::Context*) = 0;

    virtual ::Ice::StringSeq getAllRegistryNames(const ::Ice::Context*) = 0;

    virtual void shutdown(const ::Ice::Context*) = 0;

    virtual ::Ice::SliceChecksumDict getSliceChecksums(const ::Ice::Context*) = 0;
};

class ICE_GRID_API FileIterator : virtual public ::IceDelegate::Ice::Object
{
public:

    virtual bool read(::Ice::Int, ::Ice::StringSeq&, const ::Ice::Context*) = 0;

    virtual void destroy(const ::Ice::Context*) = 0;
};

class ICE_GRID_API AdminSession : virtual public ::IceDelegate::Glacier2::Session
{
public:

    virtual void keepAlive(const ::Ice::Context*) = 0;

    virtual ::IceGrid::AdminPrx getAdmin(const ::Ice::Context*) = 0;

    virtual ::Ice::ObjectPrx getAdminCallbackTemplate(const ::Ice::Context*) = 0;

    virtual void setObservers(const ::IceGrid::RegistryObserverPrx&, const ::IceGrid::NodeObserverPrx&, const ::IceGrid::ApplicationObserverPrx&, const ::IceGrid::AdapterObserverPrx&, const ::IceGrid::ObjectObserverPrx&, const ::Ice::Context*) = 0;

    virtual void setObserversByIdentity(const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Context*) = 0;

    virtual ::Ice::Int startUpdate(const ::Ice::Context*) = 0;

    virtual void finishUpdate(const ::Ice::Context*) = 0;

    virtual ::std::string getReplicaName(const ::Ice::Context*) = 0;

    virtual ::IceGrid::FileIteratorPrx openServerLog(const ::std::string&, const ::std::string&, ::Ice::Int, const ::Ice::Context*) = 0;

    virtual ::IceGrid::FileIteratorPrx openServerStdErr(const ::std::string&, ::Ice::Int, const ::Ice::Context*) = 0;

    virtual ::IceGrid::FileIteratorPrx openServerStdOut(const ::std::string&, ::Ice::Int, const ::Ice::Context*) = 0;

    virtual ::IceGrid::FileIteratorPrx openNodeStdErr(const ::std::string&, ::Ice::Int, const ::Ice::Context*) = 0;

    virtual ::IceGrid::FileIteratorPrx openNodeStdOut(const ::std::string&, ::Ice::Int, const ::Ice::Context*) = 0;

    virtual ::IceGrid::FileIteratorPrx openRegistryStdErr(const ::std::string&, ::Ice::Int, const ::Ice::Context*) = 0;

    virtual ::IceGrid::FileIteratorPrx openRegistryStdOut(const ::std::string&, ::Ice::Int, const ::Ice::Context*) = 0;
};

}

}

namespace IceDelegateM
{

namespace IceGrid
{

class ICE_GRID_API Admin : virtual public ::IceDelegate::IceGrid::Admin,
                           virtual public ::IceDelegateM::Ice::Object
{
public:

    virtual void addApplication(const ::IceGrid::ApplicationDescriptor&, const ::Ice::Context*);

    virtual void syncApplication(const ::IceGrid::ApplicationDescriptor&, const ::Ice::Context*);

    virtual void updateApplication(const ::IceGrid::ApplicationUpdateDescriptor&, const ::Ice::Context*);

    virtual void removeApplication(const ::std::string&, const ::Ice::Context*);

    virtual void instantiateServer(const ::std::string&, const ::std::string&, const ::IceGrid::ServerInstanceDescriptor&, const ::Ice::Context*);

    virtual void patchApplication(const ::std::string&, bool, const ::Ice::Context*);

    virtual ::IceGrid::ApplicationInfo getApplicationInfo(const ::std::string&, const ::Ice::Context*);

    virtual ::IceGrid::ApplicationDescriptor getDefaultApplicationDescriptor(const ::Ice::Context*);

    virtual ::Ice::StringSeq getAllApplicationNames(const ::Ice::Context*);

    virtual ::IceGrid::ServerInfo getServerInfo(const ::std::string&, const ::Ice::Context*);

    virtual ::IceGrid::ServerState getServerState(const ::std::string&, const ::Ice::Context*);

    virtual ::Ice::Int getServerPid(const ::std::string&, const ::Ice::Context*);

    virtual ::std::string getServerAdminCategory(const ::Ice::Context*);

    virtual ::Ice::ObjectPrx getServerAdmin(const ::std::string&, const ::Ice::Context*);

    virtual void enableServer(const ::std::string&, bool, const ::Ice::Context*);

    virtual bool isServerEnabled(const ::std::string&, const ::Ice::Context*);

    virtual void startServer(const ::std::string&, const ::Ice::Context*);

    virtual void stopServer(const ::std::string&, const ::Ice::Context*);

    virtual void patchServer(const ::std::string&, bool, const ::Ice::Context*);

    virtual void sendSignal(const ::std::string&, const ::std::string&, const ::Ice::Context*);

    virtual void writeMessage(const ::std::string&, const ::std::string&, ::Ice::Int, const ::Ice::Context*);

    virtual ::Ice::StringSeq getAllServerIds(const ::Ice::Context*);

    virtual ::IceGrid::AdapterInfoSeq getAdapterInfo(const ::std::string&, const ::Ice::Context*);

    virtual void removeAdapter(const ::std::string&, const ::Ice::Context*);

    virtual ::Ice::StringSeq getAllAdapterIds(const ::Ice::Context*);

    virtual void addObject(const ::Ice::ObjectPrx&, const ::Ice::Context*);

    virtual void updateObject(const ::Ice::ObjectPrx&, const ::Ice::Context*);

    virtual void addObjectWithType(const ::Ice::ObjectPrx&, const ::std::string&, const ::Ice::Context*);

    virtual void removeObject(const ::Ice::Identity&, const ::Ice::Context*);

    virtual ::IceGrid::ObjectInfo getObjectInfo(const ::Ice::Identity&, const ::Ice::Context*);

    virtual ::IceGrid::ObjectInfoSeq getObjectInfosByType(const ::std::string&, const ::Ice::Context*);

    virtual ::IceGrid::ObjectInfoSeq getAllObjectInfos(const ::std::string&, const ::Ice::Context*);

    virtual bool pingNode(const ::std::string&, const ::Ice::Context*);

    virtual ::IceGrid::LoadInfo getNodeLoad(const ::std::string&, const ::Ice::Context*);

    virtual ::IceGrid::NodeInfo getNodeInfo(const ::std::string&, const ::Ice::Context*);

    virtual ::Ice::Int getNodeProcessorSocketCount(const ::std::string&, const ::Ice::Context*);

    virtual void shutdownNode(const ::std::string&, const ::Ice::Context*);

    virtual ::std::string getNodeHostname(const ::std::string&, const ::Ice::Context*);

    virtual ::Ice::StringSeq getAllNodeNames(const ::Ice::Context*);

    virtual bool pingRegistry(const ::std::string&, const ::Ice::Context*);

    virtual ::IceGrid::RegistryInfo getRegistryInfo(const ::std::string&, const ::Ice::Context*);

    virtual void shutdownRegistry(const ::std::string&, const ::Ice::Context*);

    virtual ::Ice::StringSeq getAllRegistryNames(const ::Ice::Context*);

    virtual void shutdown(const ::Ice::Context*);

    virtual ::Ice::SliceChecksumDict getSliceChecksums(const ::Ice::Context*);
};

class ICE_GRID_API FileIterator : virtual public ::IceDelegate::IceGrid::FileIterator,
                                  virtual public ::IceDelegateM::Ice::Object
{
public:

    virtual bool read(::Ice::Int, ::Ice::StringSeq&, const ::Ice::Context*);

    virtual void destroy(const ::Ice::Context*);
};

class ICE_GRID_API AdminSession : virtual public ::IceDelegate::IceGrid::AdminSession,
                                  virtual public ::IceDelegateM::Glacier2::Session
{
public:

    virtual void keepAlive(const ::Ice::Context*);

    virtual ::IceGrid::AdminPrx getAdmin(const ::Ice::Context*);

    virtual ::Ice::ObjectPrx getAdminCallbackTemplate(const ::Ice::Context*);

    virtual void setObservers(const ::IceGrid::RegistryObserverPrx&, const ::IceGrid::NodeObserverPrx&, const ::IceGrid::ApplicationObserverPrx&, const ::IceGrid::AdapterObserverPrx&, const ::IceGrid::ObjectObserverPrx&, const ::Ice::Context*);

    virtual void setObserversByIdentity(const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Context*);

    virtual ::Ice::Int startUpdate(const ::Ice::Context*);

    virtual void finishUpdate(const ::Ice::Context*);

    virtual ::std::string getReplicaName(const ::Ice::Context*);

    virtual ::IceGrid::FileIteratorPrx openServerLog(const ::std::string&, const ::std::string&, ::Ice::Int, const ::Ice::Context*);

    virtual ::IceGrid::FileIteratorPrx openServerStdErr(const ::std::string&, ::Ice::Int, const ::Ice::Context*);

    virtual ::IceGrid::FileIteratorPrx openServerStdOut(const ::std::string&, ::Ice::Int, const ::Ice::Context*);

    virtual ::IceGrid::FileIteratorPrx openNodeStdErr(const ::std::string&, ::Ice::Int, const ::Ice::Context*);

    virtual ::IceGrid::FileIteratorPrx openNodeStdOut(const ::std::string&, ::Ice::Int, const ::Ice::Context*);

    virtual ::IceGrid::FileIteratorPrx openRegistryStdErr(const ::std::string&, ::Ice::Int, const ::Ice::Context*);

    virtual ::IceGrid::FileIteratorPrx openRegistryStdOut(const ::std::string&, ::Ice::Int, const ::Ice::Context*);
};

}

}

namespace IceDelegateD
{

namespace IceGrid
{

class ICE_GRID_API Admin : virtual public ::IceDelegate::IceGrid::Admin,
                           virtual public ::IceDelegateD::Ice::Object
{
public:

    virtual void addApplication(const ::IceGrid::ApplicationDescriptor&, const ::Ice::Context*);

    virtual void syncApplication(const ::IceGrid::ApplicationDescriptor&, const ::Ice::Context*);

    virtual void updateApplication(const ::IceGrid::ApplicationUpdateDescriptor&, const ::Ice::Context*);

    virtual void removeApplication(const ::std::string&, const ::Ice::Context*);

    virtual void instantiateServer(const ::std::string&, const ::std::string&, const ::IceGrid::ServerInstanceDescriptor&, const ::Ice::Context*);

    virtual void patchApplication(const ::std::string&, bool, const ::Ice::Context*);

    virtual ::IceGrid::ApplicationInfo getApplicationInfo(const ::std::string&, const ::Ice::Context*);

    virtual ::IceGrid::ApplicationDescriptor getDefaultApplicationDescriptor(const ::Ice::Context*);

    virtual ::Ice::StringSeq getAllApplicationNames(const ::Ice::Context*);

    virtual ::IceGrid::ServerInfo getServerInfo(const ::std::string&, const ::Ice::Context*);

    virtual ::IceGrid::ServerState getServerState(const ::std::string&, const ::Ice::Context*);

    virtual ::Ice::Int getServerPid(const ::std::string&, const ::Ice::Context*);

    virtual ::std::string getServerAdminCategory(const ::Ice::Context*);

    virtual ::Ice::ObjectPrx getServerAdmin(const ::std::string&, const ::Ice::Context*);

    virtual void enableServer(const ::std::string&, bool, const ::Ice::Context*);

    virtual bool isServerEnabled(const ::std::string&, const ::Ice::Context*);

    virtual void startServer(const ::std::string&, const ::Ice::Context*);

    virtual void stopServer(const ::std::string&, const ::Ice::Context*);

    virtual void patchServer(const ::std::string&, bool, const ::Ice::Context*);

    virtual void sendSignal(const ::std::string&, const ::std::string&, const ::Ice::Context*);

    virtual void writeMessage(const ::std::string&, const ::std::string&, ::Ice::Int, const ::Ice::Context*);

    virtual ::Ice::StringSeq getAllServerIds(const ::Ice::Context*);

    virtual ::IceGrid::AdapterInfoSeq getAdapterInfo(const ::std::string&, const ::Ice::Context*);

    virtual void removeAdapter(const ::std::string&, const ::Ice::Context*);

    virtual ::Ice::StringSeq getAllAdapterIds(const ::Ice::Context*);

    virtual void addObject(const ::Ice::ObjectPrx&, const ::Ice::Context*);

    virtual void updateObject(const ::Ice::ObjectPrx&, const ::Ice::Context*);

    virtual void addObjectWithType(const ::Ice::ObjectPrx&, const ::std::string&, const ::Ice::Context*);

    virtual void removeObject(const ::Ice::Identity&, const ::Ice::Context*);

    virtual ::IceGrid::ObjectInfo getObjectInfo(const ::Ice::Identity&, const ::Ice::Context*);

    virtual ::IceGrid::ObjectInfoSeq getObjectInfosByType(const ::std::string&, const ::Ice::Context*);

    virtual ::IceGrid::ObjectInfoSeq getAllObjectInfos(const ::std::string&, const ::Ice::Context*);

    virtual bool pingNode(const ::std::string&, const ::Ice::Context*);

    virtual ::IceGrid::LoadInfo getNodeLoad(const ::std::string&, const ::Ice::Context*);

    virtual ::IceGrid::NodeInfo getNodeInfo(const ::std::string&, const ::Ice::Context*);

    virtual ::Ice::Int getNodeProcessorSocketCount(const ::std::string&, const ::Ice::Context*);

    virtual void shutdownNode(const ::std::string&, const ::Ice::Context*);

    virtual ::std::string getNodeHostname(const ::std::string&, const ::Ice::Context*);

    virtual ::Ice::StringSeq getAllNodeNames(const ::Ice::Context*);

    virtual bool pingRegistry(const ::std::string&, const ::Ice::Context*);

    virtual ::IceGrid::RegistryInfo getRegistryInfo(const ::std::string&, const ::Ice::Context*);

    virtual void shutdownRegistry(const ::std::string&, const ::Ice::Context*);

    virtual ::Ice::StringSeq getAllRegistryNames(const ::Ice::Context*);

    virtual void shutdown(const ::Ice::Context*);

    virtual ::Ice::SliceChecksumDict getSliceChecksums(const ::Ice::Context*);
};

class ICE_GRID_API FileIterator : virtual public ::IceDelegate::IceGrid::FileIterator,
                                  virtual public ::IceDelegateD::Ice::Object
{
public:

    virtual bool read(::Ice::Int, ::Ice::StringSeq&, const ::Ice::Context*);

    virtual void destroy(const ::Ice::Context*);
};

class ICE_GRID_API AdminSession : virtual public ::IceDelegate::IceGrid::AdminSession,
                                  virtual public ::IceDelegateD::Glacier2::Session
{
public:

    virtual void keepAlive(const ::Ice::Context*);

    virtual ::IceGrid::AdminPrx getAdmin(const ::Ice::Context*);

    virtual ::Ice::ObjectPrx getAdminCallbackTemplate(const ::Ice::Context*);

    virtual void setObservers(const ::IceGrid::RegistryObserverPrx&, const ::IceGrid::NodeObserverPrx&, const ::IceGrid::ApplicationObserverPrx&, const ::IceGrid::AdapterObserverPrx&, const ::IceGrid::ObjectObserverPrx&, const ::Ice::Context*);

    virtual void setObserversByIdentity(const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Context*);

    virtual ::Ice::Int startUpdate(const ::Ice::Context*);

    virtual void finishUpdate(const ::Ice::Context*);

    virtual ::std::string getReplicaName(const ::Ice::Context*);

    virtual ::IceGrid::FileIteratorPrx openServerLog(const ::std::string&, const ::std::string&, ::Ice::Int, const ::Ice::Context*);

    virtual ::IceGrid::FileIteratorPrx openServerStdErr(const ::std::string&, ::Ice::Int, const ::Ice::Context*);

    virtual ::IceGrid::FileIteratorPrx openServerStdOut(const ::std::string&, ::Ice::Int, const ::Ice::Context*);

    virtual ::IceGrid::FileIteratorPrx openNodeStdErr(const ::std::string&, ::Ice::Int, const ::Ice::Context*);

    virtual ::IceGrid::FileIteratorPrx openNodeStdOut(const ::std::string&, ::Ice::Int, const ::Ice::Context*);

    virtual ::IceGrid::FileIteratorPrx openRegistryStdErr(const ::std::string&, ::Ice::Int, const ::Ice::Context*);

    virtual ::IceGrid::FileIteratorPrx openRegistryStdOut(const ::std::string&, ::Ice::Int, const ::Ice::Context*);
};

}

}

namespace IceGrid
{

class ICE_GRID_API Admin : virtual public ::Ice::Object
{
public:

    typedef AdminPrx ProxyType;
    typedef AdminPtr PointerType;
    
    virtual ::Ice::ObjectPtr ice_clone() const;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();

    virtual void addApplication(const ::IceGrid::ApplicationDescriptor&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___addApplication(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void syncApplication(const ::IceGrid::ApplicationDescriptor&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___syncApplication(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void updateApplication(const ::IceGrid::ApplicationUpdateDescriptor&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___updateApplication(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void removeApplication(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___removeApplication(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void instantiateServer(const ::std::string&, const ::std::string&, const ::IceGrid::ServerInstanceDescriptor&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___instantiateServer(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void patchApplication_async(const ::IceGrid::AMD_Admin_patchApplicationPtr&, const ::std::string&, bool, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___patchApplication(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::IceGrid::ApplicationInfo getApplicationInfo(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getApplicationInfo(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual ::IceGrid::ApplicationDescriptor getDefaultApplicationDescriptor(const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getDefaultApplicationDescriptor(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual ::Ice::StringSeq getAllApplicationNames(const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getAllApplicationNames(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual ::IceGrid::ServerInfo getServerInfo(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getServerInfo(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual ::IceGrid::ServerState getServerState(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getServerState(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual ::Ice::Int getServerPid(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getServerPid(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual ::std::string getServerAdminCategory(const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getServerAdminCategory(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual ::Ice::ObjectPrx getServerAdmin(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getServerAdmin(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual void enableServer(const ::std::string&, bool, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___enableServer(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual bool isServerEnabled(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___isServerEnabled(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual void startServer_async(const ::IceGrid::AMD_Admin_startServerPtr&, const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___startServer(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void stopServer_async(const ::IceGrid::AMD_Admin_stopServerPtr&, const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___stopServer(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void patchServer_async(const ::IceGrid::AMD_Admin_patchServerPtr&, const ::std::string&, bool, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___patchServer(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void sendSignal(const ::std::string&, const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___sendSignal(::IceInternal::Incoming&, const ::Ice::Current&);

    ICE_DEPRECATED_API virtual void writeMessage(const ::std::string&, const ::std::string&, ::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___writeMessage(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::Ice::StringSeq getAllServerIds(const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getAllServerIds(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual ::IceGrid::AdapterInfoSeq getAdapterInfo(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getAdapterInfo(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual void removeAdapter(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___removeAdapter(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::Ice::StringSeq getAllAdapterIds(const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getAllAdapterIds(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual void addObject(const ::Ice::ObjectPrx&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___addObject(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void updateObject(const ::Ice::ObjectPrx&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___updateObject(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void addObjectWithType(const ::Ice::ObjectPrx&, const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___addObjectWithType(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void removeObject(const ::Ice::Identity&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___removeObject(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::IceGrid::ObjectInfo getObjectInfo(const ::Ice::Identity&, const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getObjectInfo(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual ::IceGrid::ObjectInfoSeq getObjectInfosByType(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getObjectInfosByType(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual ::IceGrid::ObjectInfoSeq getAllObjectInfos(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getAllObjectInfos(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual bool pingNode(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___pingNode(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual ::IceGrid::LoadInfo getNodeLoad(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getNodeLoad(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual ::IceGrid::NodeInfo getNodeInfo(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getNodeInfo(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual ::Ice::Int getNodeProcessorSocketCount(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getNodeProcessorSocketCount(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual void shutdownNode(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___shutdownNode(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::std::string getNodeHostname(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getNodeHostname(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual ::Ice::StringSeq getAllNodeNames(const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getAllNodeNames(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual bool pingRegistry(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___pingRegistry(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual ::IceGrid::RegistryInfo getRegistryInfo(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getRegistryInfo(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual void shutdownRegistry(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___shutdownRegistry(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::Ice::StringSeq getAllRegistryNames(const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getAllRegistryNames(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual void shutdown(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___shutdown(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::Ice::SliceChecksumDict getSliceChecksums(const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getSliceChecksums(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void __write(::IceInternal::BasicStream*) const;
    virtual void __read(::IceInternal::BasicStream*, bool);
// COMPILERFIX: Stream API is not supported with VC++ 6
#if !defined(_MSC_VER) || (_MSC_VER >= 1300)
    virtual void __write(const ::Ice::OutputStreamPtr&) const;
    virtual void __read(const ::Ice::InputStreamPtr&, bool);
#endif
};

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

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

class ICE_GRID_API FileIterator : virtual public ::Ice::Object
{
public:

    typedef FileIteratorPrx ProxyType;
    typedef FileIteratorPtr PointerType;
    
    virtual ::Ice::ObjectPtr ice_clone() const;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();

    virtual bool read(::Ice::Int, ::Ice::StringSeq&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___read(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void destroy(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___destroy(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void __write(::IceInternal::BasicStream*) const;
    virtual void __read(::IceInternal::BasicStream*, bool);
// COMPILERFIX: Stream API is not supported with VC++ 6
#if !defined(_MSC_VER) || (_MSC_VER >= 1300)
    virtual void __write(const ::Ice::OutputStreamPtr&) const;
    virtual void __read(const ::Ice::InputStreamPtr&, bool);
#endif
};

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

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

class ICE_GRID_API AdminSession : virtual public ::Glacier2::Session
{
public:

    typedef AdminSessionPrx ProxyType;
    typedef AdminSessionPtr PointerType;
    
    virtual ::Ice::ObjectPtr ice_clone() const;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();

    virtual void keepAlive(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___keepAlive(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::IceGrid::AdminPrx getAdmin(const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getAdmin(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual ::Ice::ObjectPrx getAdminCallbackTemplate(const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getAdminCallbackTemplate(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual void setObservers(const ::IceGrid::RegistryObserverPrx&, const ::IceGrid::NodeObserverPrx&, const ::IceGrid::ApplicationObserverPrx&, const ::IceGrid::AdapterObserverPrx&, const ::IceGrid::ObjectObserverPrx&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___setObservers(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void setObserversByIdentity(const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___setObserversByIdentity(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::Ice::Int startUpdate(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___startUpdate(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void finishUpdate(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___finishUpdate(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::std::string getReplicaName(const ::Ice::Current& = ::Ice::Current()) const = 0;
    ::Ice::DispatchStatus ___getReplicaName(::IceInternal::Incoming&, const ::Ice::Current&) const;

    virtual ::IceGrid::FileIteratorPrx openServerLog(const ::std::string&, const ::std::string&, ::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___openServerLog(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::IceGrid::FileIteratorPrx openServerStdErr(const ::std::string&, ::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___openServerStdErr(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::IceGrid::FileIteratorPrx openServerStdOut(const ::std::string&, ::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___openServerStdOut(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::IceGrid::FileIteratorPrx openNodeStdErr(const ::std::string&, ::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___openNodeStdErr(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::IceGrid::FileIteratorPrx openNodeStdOut(const ::std::string&, ::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___openNodeStdOut(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::IceGrid::FileIteratorPrx openRegistryStdErr(const ::std::string&, ::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___openRegistryStdErr(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::IceGrid::FileIteratorPrx openRegistryStdOut(const ::std::string&, ::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___openRegistryStdOut(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void __write(::IceInternal::BasicStream*) const;
    virtual void __read(::IceInternal::BasicStream*, bool);
// COMPILERFIX: Stream API is not supported with VC++ 6
#if !defined(_MSC_VER) || (_MSC_VER >= 1300)
    virtual void __write(const ::Ice::OutputStreamPtr&) const;
    virtual void __read(const ::Ice::InputStreamPtr&, bool);
#endif
};

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

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

}

namespace IceGrid
{

template<class T>
class CallbackNC_Admin_addApplication : public Callback_Admin_addApplication_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Admin_addApplication(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_addApplication(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)();
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)();
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_addApplicationPtr
newCallback_Admin_addApplication(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_addApplication<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_addApplicationPtr
newCallback_Admin_addApplication(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_addApplication<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Admin_addApplicationPtr
newCallback_Admin_addApplication(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_addApplication<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_addApplicationPtr
newCallback_Admin_addApplication(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_addApplication<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_addApplication : public Callback_Admin_addApplication_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Admin_addApplication(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_addApplication(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_addApplicationPtr
newCallback_Admin_addApplication(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_addApplication<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_addApplicationPtr
newCallback_Admin_addApplication(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_addApplication<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_addApplicationPtr
newCallback_Admin_addApplication(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_addApplication<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_addApplicationPtr
newCallback_Admin_addApplication(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_addApplication<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_syncApplication : public Callback_Admin_syncApplication_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Admin_syncApplication(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_syncApplication(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)();
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)();
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_syncApplicationPtr
newCallback_Admin_syncApplication(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_syncApplication<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_syncApplicationPtr
newCallback_Admin_syncApplication(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_syncApplication<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Admin_syncApplicationPtr
newCallback_Admin_syncApplication(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_syncApplication<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_syncApplicationPtr
newCallback_Admin_syncApplication(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_syncApplication<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_syncApplication : public Callback_Admin_syncApplication_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Admin_syncApplication(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_syncApplication(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_syncApplicationPtr
newCallback_Admin_syncApplication(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_syncApplication<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_syncApplicationPtr
newCallback_Admin_syncApplication(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_syncApplication<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_syncApplicationPtr
newCallback_Admin_syncApplication(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_syncApplication<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_syncApplicationPtr
newCallback_Admin_syncApplication(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_syncApplication<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_updateApplication : public Callback_Admin_updateApplication_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Admin_updateApplication(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_updateApplication(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)();
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)();
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_updateApplicationPtr
newCallback_Admin_updateApplication(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_updateApplication<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_updateApplicationPtr
newCallback_Admin_updateApplication(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_updateApplication<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Admin_updateApplicationPtr
newCallback_Admin_updateApplication(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_updateApplication<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_updateApplicationPtr
newCallback_Admin_updateApplication(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_updateApplication<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_updateApplication : public Callback_Admin_updateApplication_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Admin_updateApplication(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_updateApplication(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_updateApplicationPtr
newCallback_Admin_updateApplication(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_updateApplication<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_updateApplicationPtr
newCallback_Admin_updateApplication(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_updateApplication<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_updateApplicationPtr
newCallback_Admin_updateApplication(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_updateApplication<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_updateApplicationPtr
newCallback_Admin_updateApplication(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_updateApplication<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_removeApplication : public Callback_Admin_removeApplication_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Admin_removeApplication(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_removeApplication(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)();
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)();
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_removeApplicationPtr
newCallback_Admin_removeApplication(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_removeApplication<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_removeApplicationPtr
newCallback_Admin_removeApplication(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_removeApplication<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Admin_removeApplicationPtr
newCallback_Admin_removeApplication(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_removeApplication<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_removeApplicationPtr
newCallback_Admin_removeApplication(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_removeApplication<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_removeApplication : public Callback_Admin_removeApplication_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Admin_removeApplication(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_removeApplication(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_removeApplicationPtr
newCallback_Admin_removeApplication(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_removeApplication<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_removeApplicationPtr
newCallback_Admin_removeApplication(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_removeApplication<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_removeApplicationPtr
newCallback_Admin_removeApplication(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_removeApplication<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_removeApplicationPtr
newCallback_Admin_removeApplication(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_removeApplication<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_instantiateServer : public Callback_Admin_instantiateServer_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Admin_instantiateServer(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_instantiateServer(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)();
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)();
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_instantiateServerPtr
newCallback_Admin_instantiateServer(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_instantiateServer<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_instantiateServerPtr
newCallback_Admin_instantiateServer(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_instantiateServer<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Admin_instantiateServerPtr
newCallback_Admin_instantiateServer(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_instantiateServer<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_instantiateServerPtr
newCallback_Admin_instantiateServer(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_instantiateServer<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_instantiateServer : public Callback_Admin_instantiateServer_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Admin_instantiateServer(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_instantiateServer(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_instantiateServerPtr
newCallback_Admin_instantiateServer(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_instantiateServer<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_instantiateServerPtr
newCallback_Admin_instantiateServer(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_instantiateServer<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_instantiateServerPtr
newCallback_Admin_instantiateServer(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_instantiateServer<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_instantiateServerPtr
newCallback_Admin_instantiateServer(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_instantiateServer<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_patchApplication : public Callback_Admin_patchApplication_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Admin_patchApplication(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_patchApplication(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)();
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)();
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_patchApplicationPtr
newCallback_Admin_patchApplication(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_patchApplication<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_patchApplicationPtr
newCallback_Admin_patchApplication(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_patchApplication<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Admin_patchApplicationPtr
newCallback_Admin_patchApplication(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_patchApplication<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_patchApplicationPtr
newCallback_Admin_patchApplication(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_patchApplication<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_patchApplication : public Callback_Admin_patchApplication_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Admin_patchApplication(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_patchApplication(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_patchApplicationPtr
newCallback_Admin_patchApplication(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_patchApplication<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_patchApplicationPtr
newCallback_Admin_patchApplication(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_patchApplication<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_patchApplicationPtr
newCallback_Admin_patchApplication(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_patchApplication<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_patchApplicationPtr
newCallback_Admin_patchApplication(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_patchApplication<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_getApplicationInfo : public Callback_Admin_getApplicationInfo_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::IceGrid::ApplicationInfo&);

    CallbackNC_Admin_getApplicationInfo(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::ApplicationInfo __ret;
        try
        {
            __ret = __proxy->end_getApplicationInfo(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_getApplicationInfoPtr
newCallback_Admin_getApplicationInfo(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::ApplicationInfo&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getApplicationInfo<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_getApplicationInfoPtr
newCallback_Admin_getApplicationInfo(T* instance, void (T::*cb)(const ::IceGrid::ApplicationInfo&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getApplicationInfo<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_getApplicationInfo : public Callback_Admin_getApplicationInfo_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::IceGrid::ApplicationInfo&, const CT&);

    Callback_Admin_getApplicationInfo(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::ApplicationInfo __ret;
        try
        {
            __ret = __proxy->end_getApplicationInfo(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_getApplicationInfoPtr
newCallback_Admin_getApplicationInfo(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::ApplicationInfo&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getApplicationInfo<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_getApplicationInfoPtr
newCallback_Admin_getApplicationInfo(T* instance, void (T::*cb)(const ::IceGrid::ApplicationInfo&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getApplicationInfo<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_getDefaultApplicationDescriptor : public Callback_Admin_getDefaultApplicationDescriptor_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::IceGrid::ApplicationDescriptor&);

    CallbackNC_Admin_getDefaultApplicationDescriptor(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::ApplicationDescriptor __ret;
        try
        {
            __ret = __proxy->end_getDefaultApplicationDescriptor(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_getDefaultApplicationDescriptorPtr
newCallback_Admin_getDefaultApplicationDescriptor(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::ApplicationDescriptor&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getDefaultApplicationDescriptor<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_getDefaultApplicationDescriptorPtr
newCallback_Admin_getDefaultApplicationDescriptor(T* instance, void (T::*cb)(const ::IceGrid::ApplicationDescriptor&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getDefaultApplicationDescriptor<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_getDefaultApplicationDescriptor : public Callback_Admin_getDefaultApplicationDescriptor_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::IceGrid::ApplicationDescriptor&, const CT&);

    Callback_Admin_getDefaultApplicationDescriptor(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::ApplicationDescriptor __ret;
        try
        {
            __ret = __proxy->end_getDefaultApplicationDescriptor(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_getDefaultApplicationDescriptorPtr
newCallback_Admin_getDefaultApplicationDescriptor(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::ApplicationDescriptor&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getDefaultApplicationDescriptor<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_getDefaultApplicationDescriptorPtr
newCallback_Admin_getDefaultApplicationDescriptor(T* instance, void (T::*cb)(const ::IceGrid::ApplicationDescriptor&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getDefaultApplicationDescriptor<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_getAllApplicationNames : public Callback_Admin_getAllApplicationNames_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::Ice::StringSeq&);

    CallbackNC_Admin_getAllApplicationNames(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::Ice::StringSeq __ret;
        try
        {
            __ret = __proxy->end_getAllApplicationNames(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_getAllApplicationNamesPtr
newCallback_Admin_getAllApplicationNames(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::StringSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getAllApplicationNames<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_getAllApplicationNamesPtr
newCallback_Admin_getAllApplicationNames(T* instance, void (T::*cb)(const ::Ice::StringSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getAllApplicationNames<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_getAllApplicationNames : public Callback_Admin_getAllApplicationNames_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::Ice::StringSeq&, const CT&);

    Callback_Admin_getAllApplicationNames(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::Ice::StringSeq __ret;
        try
        {
            __ret = __proxy->end_getAllApplicationNames(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_getAllApplicationNamesPtr
newCallback_Admin_getAllApplicationNames(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::StringSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getAllApplicationNames<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_getAllApplicationNamesPtr
newCallback_Admin_getAllApplicationNames(T* instance, void (T::*cb)(const ::Ice::StringSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getAllApplicationNames<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_getServerInfo : public Callback_Admin_getServerInfo_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::IceGrid::ServerInfo&);

    CallbackNC_Admin_getServerInfo(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::ServerInfo __ret;
        try
        {
            __ret = __proxy->end_getServerInfo(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_getServerInfoPtr
newCallback_Admin_getServerInfo(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::ServerInfo&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getServerInfo<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_getServerInfoPtr
newCallback_Admin_getServerInfo(T* instance, void (T::*cb)(const ::IceGrid::ServerInfo&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getServerInfo<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_getServerInfo : public Callback_Admin_getServerInfo_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::IceGrid::ServerInfo&, const CT&);

    Callback_Admin_getServerInfo(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::ServerInfo __ret;
        try
        {
            __ret = __proxy->end_getServerInfo(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_getServerInfoPtr
newCallback_Admin_getServerInfo(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::ServerInfo&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getServerInfo<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_getServerInfoPtr
newCallback_Admin_getServerInfo(T* instance, void (T::*cb)(const ::IceGrid::ServerInfo&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getServerInfo<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_getServerState : public Callback_Admin_getServerState_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(::IceGrid::ServerState);

    CallbackNC_Admin_getServerState(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::ServerState __ret;
        try
        {
            __ret = __proxy->end_getServerState(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_getServerStatePtr
newCallback_Admin_getServerState(const IceUtil::Handle<T>& instance, void (T::*cb)(::IceGrid::ServerState), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getServerState<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_getServerStatePtr
newCallback_Admin_getServerState(T* instance, void (T::*cb)(::IceGrid::ServerState), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getServerState<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_getServerState : public Callback_Admin_getServerState_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(::IceGrid::ServerState, const CT&);

    Callback_Admin_getServerState(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::ServerState __ret;
        try
        {
            __ret = __proxy->end_getServerState(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_getServerStatePtr
newCallback_Admin_getServerState(const IceUtil::Handle<T>& instance, void (T::*cb)(::IceGrid::ServerState, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getServerState<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_getServerStatePtr
newCallback_Admin_getServerState(T* instance, void (T::*cb)(::IceGrid::ServerState, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getServerState<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_getServerPid : public Callback_Admin_getServerPid_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(::Ice::Int);

    CallbackNC_Admin_getServerPid(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::Ice::Int __ret;
        try
        {
            __ret = __proxy->end_getServerPid(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_getServerPidPtr
newCallback_Admin_getServerPid(const IceUtil::Handle<T>& instance, void (T::*cb)(::Ice::Int), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getServerPid<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_getServerPidPtr
newCallback_Admin_getServerPid(T* instance, void (T::*cb)(::Ice::Int), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getServerPid<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_getServerPid : public Callback_Admin_getServerPid_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(::Ice::Int, const CT&);

    Callback_Admin_getServerPid(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::Ice::Int __ret;
        try
        {
            __ret = __proxy->end_getServerPid(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_getServerPidPtr
newCallback_Admin_getServerPid(const IceUtil::Handle<T>& instance, void (T::*cb)(::Ice::Int, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getServerPid<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_getServerPidPtr
newCallback_Admin_getServerPid(T* instance, void (T::*cb)(::Ice::Int, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getServerPid<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_getServerAdminCategory : public Callback_Admin_getServerAdminCategory_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::std::string&);

    CallbackNC_Admin_getServerAdminCategory(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::std::string __ret;
        try
        {
            __ret = __proxy->end_getServerAdminCategory(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_getServerAdminCategoryPtr
newCallback_Admin_getServerAdminCategory(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::std::string&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getServerAdminCategory<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_getServerAdminCategoryPtr
newCallback_Admin_getServerAdminCategory(T* instance, void (T::*cb)(const ::std::string&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getServerAdminCategory<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_getServerAdminCategory : public Callback_Admin_getServerAdminCategory_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::std::string&, const CT&);

    Callback_Admin_getServerAdminCategory(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::std::string __ret;
        try
        {
            __ret = __proxy->end_getServerAdminCategory(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_getServerAdminCategoryPtr
newCallback_Admin_getServerAdminCategory(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::std::string&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getServerAdminCategory<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_getServerAdminCategoryPtr
newCallback_Admin_getServerAdminCategory(T* instance, void (T::*cb)(const ::std::string&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getServerAdminCategory<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_getServerAdmin : public Callback_Admin_getServerAdmin_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::Ice::ObjectPrx&);

    CallbackNC_Admin_getServerAdmin(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::Ice::ObjectPrx __ret;
        try
        {
            __ret = __proxy->end_getServerAdmin(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_getServerAdminPtr
newCallback_Admin_getServerAdmin(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::ObjectPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getServerAdmin<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_getServerAdminPtr
newCallback_Admin_getServerAdmin(T* instance, void (T::*cb)(const ::Ice::ObjectPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getServerAdmin<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_getServerAdmin : public Callback_Admin_getServerAdmin_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::Ice::ObjectPrx&, const CT&);

    Callback_Admin_getServerAdmin(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::Ice::ObjectPrx __ret;
        try
        {
            __ret = __proxy->end_getServerAdmin(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_getServerAdminPtr
newCallback_Admin_getServerAdmin(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::ObjectPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getServerAdmin<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_getServerAdminPtr
newCallback_Admin_getServerAdmin(T* instance, void (T::*cb)(const ::Ice::ObjectPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getServerAdmin<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_enableServer : public Callback_Admin_enableServer_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Admin_enableServer(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_enableServer(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)();
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)();
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_enableServerPtr
newCallback_Admin_enableServer(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_enableServer<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_enableServerPtr
newCallback_Admin_enableServer(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_enableServer<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Admin_enableServerPtr
newCallback_Admin_enableServer(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_enableServer<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_enableServerPtr
newCallback_Admin_enableServer(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_enableServer<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_enableServer : public Callback_Admin_enableServer_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Admin_enableServer(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_enableServer(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_enableServerPtr
newCallback_Admin_enableServer(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_enableServer<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_enableServerPtr
newCallback_Admin_enableServer(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_enableServer<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_enableServerPtr
newCallback_Admin_enableServer(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_enableServer<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_enableServerPtr
newCallback_Admin_enableServer(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_enableServer<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_isServerEnabled : public Callback_Admin_isServerEnabled_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(bool);

    CallbackNC_Admin_isServerEnabled(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        bool __ret;
        try
        {
            __ret = __proxy->end_isServerEnabled(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_isServerEnabledPtr
newCallback_Admin_isServerEnabled(const IceUtil::Handle<T>& instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_isServerEnabled<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_isServerEnabledPtr
newCallback_Admin_isServerEnabled(T* instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_isServerEnabled<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_isServerEnabled : public Callback_Admin_isServerEnabled_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(bool, const CT&);

    Callback_Admin_isServerEnabled(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        bool __ret;
        try
        {
            __ret = __proxy->end_isServerEnabled(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_isServerEnabledPtr
newCallback_Admin_isServerEnabled(const IceUtil::Handle<T>& instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_isServerEnabled<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_isServerEnabledPtr
newCallback_Admin_isServerEnabled(T* instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_isServerEnabled<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_startServer : public Callback_Admin_startServer_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Admin_startServer(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_startServer(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)();
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)();
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_startServerPtr
newCallback_Admin_startServer(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_startServer<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_startServerPtr
newCallback_Admin_startServer(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_startServer<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Admin_startServerPtr
newCallback_Admin_startServer(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_startServer<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_startServerPtr
newCallback_Admin_startServer(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_startServer<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_startServer : public Callback_Admin_startServer_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Admin_startServer(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_startServer(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_startServerPtr
newCallback_Admin_startServer(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_startServer<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_startServerPtr
newCallback_Admin_startServer(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_startServer<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_startServerPtr
newCallback_Admin_startServer(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_startServer<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_startServerPtr
newCallback_Admin_startServer(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_startServer<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_stopServer : public Callback_Admin_stopServer_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Admin_stopServer(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_stopServer(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)();
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)();
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_stopServerPtr
newCallback_Admin_stopServer(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_stopServer<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_stopServerPtr
newCallback_Admin_stopServer(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_stopServer<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Admin_stopServerPtr
newCallback_Admin_stopServer(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_stopServer<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_stopServerPtr
newCallback_Admin_stopServer(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_stopServer<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_stopServer : public Callback_Admin_stopServer_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Admin_stopServer(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_stopServer(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_stopServerPtr
newCallback_Admin_stopServer(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_stopServer<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_stopServerPtr
newCallback_Admin_stopServer(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_stopServer<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_stopServerPtr
newCallback_Admin_stopServer(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_stopServer<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_stopServerPtr
newCallback_Admin_stopServer(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_stopServer<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_patchServer : public Callback_Admin_patchServer_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Admin_patchServer(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_patchServer(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)();
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)();
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_patchServerPtr
newCallback_Admin_patchServer(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_patchServer<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_patchServerPtr
newCallback_Admin_patchServer(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_patchServer<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Admin_patchServerPtr
newCallback_Admin_patchServer(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_patchServer<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_patchServerPtr
newCallback_Admin_patchServer(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_patchServer<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_patchServer : public Callback_Admin_patchServer_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Admin_patchServer(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_patchServer(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_patchServerPtr
newCallback_Admin_patchServer(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_patchServer<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_patchServerPtr
newCallback_Admin_patchServer(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_patchServer<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_patchServerPtr
newCallback_Admin_patchServer(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_patchServer<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_patchServerPtr
newCallback_Admin_patchServer(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_patchServer<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_sendSignal : public Callback_Admin_sendSignal_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Admin_sendSignal(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_sendSignal(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)();
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)();
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_sendSignalPtr
newCallback_Admin_sendSignal(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_sendSignal<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_sendSignalPtr
newCallback_Admin_sendSignal(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_sendSignal<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Admin_sendSignalPtr
newCallback_Admin_sendSignal(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_sendSignal<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_sendSignalPtr
newCallback_Admin_sendSignal(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_sendSignal<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_sendSignal : public Callback_Admin_sendSignal_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Admin_sendSignal(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_sendSignal(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_sendSignalPtr
newCallback_Admin_sendSignal(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_sendSignal<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_sendSignalPtr
newCallback_Admin_sendSignal(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_sendSignal<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_sendSignalPtr
newCallback_Admin_sendSignal(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_sendSignal<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_sendSignalPtr
newCallback_Admin_sendSignal(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_sendSignal<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_writeMessage : public Callback_Admin_writeMessage_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Admin_writeMessage(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_writeMessage(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)();
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)();
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_writeMessagePtr
newCallback_Admin_writeMessage(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_writeMessage<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_writeMessagePtr
newCallback_Admin_writeMessage(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_writeMessage<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Admin_writeMessagePtr
newCallback_Admin_writeMessage(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_writeMessage<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_writeMessagePtr
newCallback_Admin_writeMessage(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_writeMessage<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_writeMessage : public Callback_Admin_writeMessage_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Admin_writeMessage(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_writeMessage(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_writeMessagePtr
newCallback_Admin_writeMessage(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_writeMessage<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_writeMessagePtr
newCallback_Admin_writeMessage(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_writeMessage<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_writeMessagePtr
newCallback_Admin_writeMessage(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_writeMessage<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_writeMessagePtr
newCallback_Admin_writeMessage(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_writeMessage<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_getAllServerIds : public Callback_Admin_getAllServerIds_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::Ice::StringSeq&);

    CallbackNC_Admin_getAllServerIds(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::Ice::StringSeq __ret;
        try
        {
            __ret = __proxy->end_getAllServerIds(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_getAllServerIdsPtr
newCallback_Admin_getAllServerIds(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::StringSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getAllServerIds<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_getAllServerIdsPtr
newCallback_Admin_getAllServerIds(T* instance, void (T::*cb)(const ::Ice::StringSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getAllServerIds<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_getAllServerIds : public Callback_Admin_getAllServerIds_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::Ice::StringSeq&, const CT&);

    Callback_Admin_getAllServerIds(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::Ice::StringSeq __ret;
        try
        {
            __ret = __proxy->end_getAllServerIds(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_getAllServerIdsPtr
newCallback_Admin_getAllServerIds(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::StringSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getAllServerIds<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_getAllServerIdsPtr
newCallback_Admin_getAllServerIds(T* instance, void (T::*cb)(const ::Ice::StringSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getAllServerIds<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_getAdapterInfo : public Callback_Admin_getAdapterInfo_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::IceGrid::AdapterInfoSeq&);

    CallbackNC_Admin_getAdapterInfo(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::AdapterInfoSeq __ret;
        try
        {
            __ret = __proxy->end_getAdapterInfo(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_getAdapterInfoPtr
newCallback_Admin_getAdapterInfo(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::AdapterInfoSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getAdapterInfo<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_getAdapterInfoPtr
newCallback_Admin_getAdapterInfo(T* instance, void (T::*cb)(const ::IceGrid::AdapterInfoSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getAdapterInfo<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_getAdapterInfo : public Callback_Admin_getAdapterInfo_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::IceGrid::AdapterInfoSeq&, const CT&);

    Callback_Admin_getAdapterInfo(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::AdapterInfoSeq __ret;
        try
        {
            __ret = __proxy->end_getAdapterInfo(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_getAdapterInfoPtr
newCallback_Admin_getAdapterInfo(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::AdapterInfoSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getAdapterInfo<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_getAdapterInfoPtr
newCallback_Admin_getAdapterInfo(T* instance, void (T::*cb)(const ::IceGrid::AdapterInfoSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getAdapterInfo<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_removeAdapter : public Callback_Admin_removeAdapter_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Admin_removeAdapter(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_removeAdapter(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)();
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)();
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_removeAdapterPtr
newCallback_Admin_removeAdapter(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_removeAdapter<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_removeAdapterPtr
newCallback_Admin_removeAdapter(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_removeAdapter<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Admin_removeAdapterPtr
newCallback_Admin_removeAdapter(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_removeAdapter<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_removeAdapterPtr
newCallback_Admin_removeAdapter(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_removeAdapter<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_removeAdapter : public Callback_Admin_removeAdapter_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Admin_removeAdapter(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_removeAdapter(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_removeAdapterPtr
newCallback_Admin_removeAdapter(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_removeAdapter<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_removeAdapterPtr
newCallback_Admin_removeAdapter(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_removeAdapter<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_removeAdapterPtr
newCallback_Admin_removeAdapter(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_removeAdapter<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_removeAdapterPtr
newCallback_Admin_removeAdapter(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_removeAdapter<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_getAllAdapterIds : public Callback_Admin_getAllAdapterIds_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::Ice::StringSeq&);

    CallbackNC_Admin_getAllAdapterIds(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::Ice::StringSeq __ret;
        try
        {
            __ret = __proxy->end_getAllAdapterIds(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_getAllAdapterIdsPtr
newCallback_Admin_getAllAdapterIds(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::StringSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getAllAdapterIds<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_getAllAdapterIdsPtr
newCallback_Admin_getAllAdapterIds(T* instance, void (T::*cb)(const ::Ice::StringSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getAllAdapterIds<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_getAllAdapterIds : public Callback_Admin_getAllAdapterIds_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::Ice::StringSeq&, const CT&);

    Callback_Admin_getAllAdapterIds(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::Ice::StringSeq __ret;
        try
        {
            __ret = __proxy->end_getAllAdapterIds(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_getAllAdapterIdsPtr
newCallback_Admin_getAllAdapterIds(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::StringSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getAllAdapterIds<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_getAllAdapterIdsPtr
newCallback_Admin_getAllAdapterIds(T* instance, void (T::*cb)(const ::Ice::StringSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getAllAdapterIds<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_addObject : public Callback_Admin_addObject_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Admin_addObject(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_addObject(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)();
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)();
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_addObjectPtr
newCallback_Admin_addObject(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_addObject<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_addObjectPtr
newCallback_Admin_addObject(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_addObject<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Admin_addObjectPtr
newCallback_Admin_addObject(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_addObject<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_addObjectPtr
newCallback_Admin_addObject(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_addObject<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_addObject : public Callback_Admin_addObject_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Admin_addObject(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_addObject(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_addObjectPtr
newCallback_Admin_addObject(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_addObject<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_addObjectPtr
newCallback_Admin_addObject(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_addObject<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_addObjectPtr
newCallback_Admin_addObject(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_addObject<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_addObjectPtr
newCallback_Admin_addObject(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_addObject<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_updateObject : public Callback_Admin_updateObject_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Admin_updateObject(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_updateObject(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)();
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)();
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_updateObjectPtr
newCallback_Admin_updateObject(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_updateObject<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_updateObjectPtr
newCallback_Admin_updateObject(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_updateObject<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Admin_updateObjectPtr
newCallback_Admin_updateObject(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_updateObject<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_updateObjectPtr
newCallback_Admin_updateObject(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_updateObject<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_updateObject : public Callback_Admin_updateObject_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Admin_updateObject(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_updateObject(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_updateObjectPtr
newCallback_Admin_updateObject(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_updateObject<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_updateObjectPtr
newCallback_Admin_updateObject(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_updateObject<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_updateObjectPtr
newCallback_Admin_updateObject(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_updateObject<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_updateObjectPtr
newCallback_Admin_updateObject(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_updateObject<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_addObjectWithType : public Callback_Admin_addObjectWithType_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Admin_addObjectWithType(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_addObjectWithType(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)();
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)();
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_addObjectWithTypePtr
newCallback_Admin_addObjectWithType(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_addObjectWithType<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_addObjectWithTypePtr
newCallback_Admin_addObjectWithType(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_addObjectWithType<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Admin_addObjectWithTypePtr
newCallback_Admin_addObjectWithType(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_addObjectWithType<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_addObjectWithTypePtr
newCallback_Admin_addObjectWithType(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_addObjectWithType<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_addObjectWithType : public Callback_Admin_addObjectWithType_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Admin_addObjectWithType(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_addObjectWithType(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_addObjectWithTypePtr
newCallback_Admin_addObjectWithType(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_addObjectWithType<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_addObjectWithTypePtr
newCallback_Admin_addObjectWithType(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_addObjectWithType<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_addObjectWithTypePtr
newCallback_Admin_addObjectWithType(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_addObjectWithType<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_addObjectWithTypePtr
newCallback_Admin_addObjectWithType(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_addObjectWithType<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_removeObject : public Callback_Admin_removeObject_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Admin_removeObject(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_removeObject(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)();
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)();
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_removeObjectPtr
newCallback_Admin_removeObject(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_removeObject<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_removeObjectPtr
newCallback_Admin_removeObject(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_removeObject<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Admin_removeObjectPtr
newCallback_Admin_removeObject(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_removeObject<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_removeObjectPtr
newCallback_Admin_removeObject(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_removeObject<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_removeObject : public Callback_Admin_removeObject_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Admin_removeObject(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_removeObject(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_removeObjectPtr
newCallback_Admin_removeObject(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_removeObject<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_removeObjectPtr
newCallback_Admin_removeObject(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_removeObject<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_removeObjectPtr
newCallback_Admin_removeObject(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_removeObject<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_removeObjectPtr
newCallback_Admin_removeObject(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_removeObject<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_getObjectInfo : public Callback_Admin_getObjectInfo_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::IceGrid::ObjectInfo&);

    CallbackNC_Admin_getObjectInfo(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::ObjectInfo __ret;
        try
        {
            __ret = __proxy->end_getObjectInfo(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_getObjectInfoPtr
newCallback_Admin_getObjectInfo(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::ObjectInfo&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getObjectInfo<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_getObjectInfoPtr
newCallback_Admin_getObjectInfo(T* instance, void (T::*cb)(const ::IceGrid::ObjectInfo&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getObjectInfo<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_getObjectInfo : public Callback_Admin_getObjectInfo_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::IceGrid::ObjectInfo&, const CT&);

    Callback_Admin_getObjectInfo(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::ObjectInfo __ret;
        try
        {
            __ret = __proxy->end_getObjectInfo(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_getObjectInfoPtr
newCallback_Admin_getObjectInfo(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::ObjectInfo&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getObjectInfo<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_getObjectInfoPtr
newCallback_Admin_getObjectInfo(T* instance, void (T::*cb)(const ::IceGrid::ObjectInfo&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getObjectInfo<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_getObjectInfosByType : public Callback_Admin_getObjectInfosByType_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::IceGrid::ObjectInfoSeq&);

    CallbackNC_Admin_getObjectInfosByType(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::ObjectInfoSeq __ret;
        try
        {
            __ret = __proxy->end_getObjectInfosByType(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_getObjectInfosByTypePtr
newCallback_Admin_getObjectInfosByType(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::ObjectInfoSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getObjectInfosByType<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_getObjectInfosByTypePtr
newCallback_Admin_getObjectInfosByType(T* instance, void (T::*cb)(const ::IceGrid::ObjectInfoSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getObjectInfosByType<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_getObjectInfosByType : public Callback_Admin_getObjectInfosByType_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::IceGrid::ObjectInfoSeq&, const CT&);

    Callback_Admin_getObjectInfosByType(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::ObjectInfoSeq __ret;
        try
        {
            __ret = __proxy->end_getObjectInfosByType(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_getObjectInfosByTypePtr
newCallback_Admin_getObjectInfosByType(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::ObjectInfoSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getObjectInfosByType<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_getObjectInfosByTypePtr
newCallback_Admin_getObjectInfosByType(T* instance, void (T::*cb)(const ::IceGrid::ObjectInfoSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getObjectInfosByType<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_getAllObjectInfos : public Callback_Admin_getAllObjectInfos_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::IceGrid::ObjectInfoSeq&);

    CallbackNC_Admin_getAllObjectInfos(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::ObjectInfoSeq __ret;
        try
        {
            __ret = __proxy->end_getAllObjectInfos(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_getAllObjectInfosPtr
newCallback_Admin_getAllObjectInfos(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::ObjectInfoSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getAllObjectInfos<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_getAllObjectInfosPtr
newCallback_Admin_getAllObjectInfos(T* instance, void (T::*cb)(const ::IceGrid::ObjectInfoSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getAllObjectInfos<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_getAllObjectInfos : public Callback_Admin_getAllObjectInfos_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::IceGrid::ObjectInfoSeq&, const CT&);

    Callback_Admin_getAllObjectInfos(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::ObjectInfoSeq __ret;
        try
        {
            __ret = __proxy->end_getAllObjectInfos(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_getAllObjectInfosPtr
newCallback_Admin_getAllObjectInfos(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::ObjectInfoSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getAllObjectInfos<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_getAllObjectInfosPtr
newCallback_Admin_getAllObjectInfos(T* instance, void (T::*cb)(const ::IceGrid::ObjectInfoSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getAllObjectInfos<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_pingNode : public Callback_Admin_pingNode_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(bool);

    CallbackNC_Admin_pingNode(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        bool __ret;
        try
        {
            __ret = __proxy->end_pingNode(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_pingNodePtr
newCallback_Admin_pingNode(const IceUtil::Handle<T>& instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_pingNode<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_pingNodePtr
newCallback_Admin_pingNode(T* instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_pingNode<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_pingNode : public Callback_Admin_pingNode_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(bool, const CT&);

    Callback_Admin_pingNode(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        bool __ret;
        try
        {
            __ret = __proxy->end_pingNode(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_pingNodePtr
newCallback_Admin_pingNode(const IceUtil::Handle<T>& instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_pingNode<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_pingNodePtr
newCallback_Admin_pingNode(T* instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_pingNode<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_getNodeLoad : public Callback_Admin_getNodeLoad_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::IceGrid::LoadInfo&);

    CallbackNC_Admin_getNodeLoad(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::LoadInfo __ret;
        try
        {
            __ret = __proxy->end_getNodeLoad(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_getNodeLoadPtr
newCallback_Admin_getNodeLoad(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::LoadInfo&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getNodeLoad<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_getNodeLoadPtr
newCallback_Admin_getNodeLoad(T* instance, void (T::*cb)(const ::IceGrid::LoadInfo&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getNodeLoad<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_getNodeLoad : public Callback_Admin_getNodeLoad_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::IceGrid::LoadInfo&, const CT&);

    Callback_Admin_getNodeLoad(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::LoadInfo __ret;
        try
        {
            __ret = __proxy->end_getNodeLoad(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_getNodeLoadPtr
newCallback_Admin_getNodeLoad(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::LoadInfo&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getNodeLoad<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_getNodeLoadPtr
newCallback_Admin_getNodeLoad(T* instance, void (T::*cb)(const ::IceGrid::LoadInfo&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getNodeLoad<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_getNodeInfo : public Callback_Admin_getNodeInfo_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::IceGrid::NodeInfo&);

    CallbackNC_Admin_getNodeInfo(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::NodeInfo __ret;
        try
        {
            __ret = __proxy->end_getNodeInfo(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_getNodeInfoPtr
newCallback_Admin_getNodeInfo(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::NodeInfo&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getNodeInfo<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_getNodeInfoPtr
newCallback_Admin_getNodeInfo(T* instance, void (T::*cb)(const ::IceGrid::NodeInfo&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getNodeInfo<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_getNodeInfo : public Callback_Admin_getNodeInfo_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::IceGrid::NodeInfo&, const CT&);

    Callback_Admin_getNodeInfo(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::NodeInfo __ret;
        try
        {
            __ret = __proxy->end_getNodeInfo(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_getNodeInfoPtr
newCallback_Admin_getNodeInfo(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::NodeInfo&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getNodeInfo<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_getNodeInfoPtr
newCallback_Admin_getNodeInfo(T* instance, void (T::*cb)(const ::IceGrid::NodeInfo&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getNodeInfo<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_getNodeProcessorSocketCount : public Callback_Admin_getNodeProcessorSocketCount_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(::Ice::Int);

    CallbackNC_Admin_getNodeProcessorSocketCount(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::Ice::Int __ret;
        try
        {
            __ret = __proxy->end_getNodeProcessorSocketCount(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_getNodeProcessorSocketCountPtr
newCallback_Admin_getNodeProcessorSocketCount(const IceUtil::Handle<T>& instance, void (T::*cb)(::Ice::Int), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getNodeProcessorSocketCount<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_getNodeProcessorSocketCountPtr
newCallback_Admin_getNodeProcessorSocketCount(T* instance, void (T::*cb)(::Ice::Int), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getNodeProcessorSocketCount<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_getNodeProcessorSocketCount : public Callback_Admin_getNodeProcessorSocketCount_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(::Ice::Int, const CT&);

    Callback_Admin_getNodeProcessorSocketCount(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::Ice::Int __ret;
        try
        {
            __ret = __proxy->end_getNodeProcessorSocketCount(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_getNodeProcessorSocketCountPtr
newCallback_Admin_getNodeProcessorSocketCount(const IceUtil::Handle<T>& instance, void (T::*cb)(::Ice::Int, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getNodeProcessorSocketCount<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_getNodeProcessorSocketCountPtr
newCallback_Admin_getNodeProcessorSocketCount(T* instance, void (T::*cb)(::Ice::Int, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getNodeProcessorSocketCount<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_shutdownNode : public Callback_Admin_shutdownNode_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Admin_shutdownNode(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_shutdownNode(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)();
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)();
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_shutdownNodePtr
newCallback_Admin_shutdownNode(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_shutdownNode<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_shutdownNodePtr
newCallback_Admin_shutdownNode(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_shutdownNode<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Admin_shutdownNodePtr
newCallback_Admin_shutdownNode(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_shutdownNode<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_shutdownNodePtr
newCallback_Admin_shutdownNode(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_shutdownNode<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_shutdownNode : public Callback_Admin_shutdownNode_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Admin_shutdownNode(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_shutdownNode(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_shutdownNodePtr
newCallback_Admin_shutdownNode(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_shutdownNode<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_shutdownNodePtr
newCallback_Admin_shutdownNode(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_shutdownNode<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_shutdownNodePtr
newCallback_Admin_shutdownNode(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_shutdownNode<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_shutdownNodePtr
newCallback_Admin_shutdownNode(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_shutdownNode<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_getNodeHostname : public Callback_Admin_getNodeHostname_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::std::string&);

    CallbackNC_Admin_getNodeHostname(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::std::string __ret;
        try
        {
            __ret = __proxy->end_getNodeHostname(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_getNodeHostnamePtr
newCallback_Admin_getNodeHostname(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::std::string&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getNodeHostname<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_getNodeHostnamePtr
newCallback_Admin_getNodeHostname(T* instance, void (T::*cb)(const ::std::string&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getNodeHostname<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_getNodeHostname : public Callback_Admin_getNodeHostname_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::std::string&, const CT&);

    Callback_Admin_getNodeHostname(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::std::string __ret;
        try
        {
            __ret = __proxy->end_getNodeHostname(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_getNodeHostnamePtr
newCallback_Admin_getNodeHostname(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::std::string&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getNodeHostname<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_getNodeHostnamePtr
newCallback_Admin_getNodeHostname(T* instance, void (T::*cb)(const ::std::string&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getNodeHostname<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_getAllNodeNames : public Callback_Admin_getAllNodeNames_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::Ice::StringSeq&);

    CallbackNC_Admin_getAllNodeNames(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::Ice::StringSeq __ret;
        try
        {
            __ret = __proxy->end_getAllNodeNames(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_getAllNodeNamesPtr
newCallback_Admin_getAllNodeNames(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::StringSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getAllNodeNames<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_getAllNodeNamesPtr
newCallback_Admin_getAllNodeNames(T* instance, void (T::*cb)(const ::Ice::StringSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getAllNodeNames<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_getAllNodeNames : public Callback_Admin_getAllNodeNames_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::Ice::StringSeq&, const CT&);

    Callback_Admin_getAllNodeNames(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::Ice::StringSeq __ret;
        try
        {
            __ret = __proxy->end_getAllNodeNames(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_getAllNodeNamesPtr
newCallback_Admin_getAllNodeNames(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::StringSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getAllNodeNames<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_getAllNodeNamesPtr
newCallback_Admin_getAllNodeNames(T* instance, void (T::*cb)(const ::Ice::StringSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getAllNodeNames<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_pingRegistry : public Callback_Admin_pingRegistry_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(bool);

    CallbackNC_Admin_pingRegistry(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        bool __ret;
        try
        {
            __ret = __proxy->end_pingRegistry(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_pingRegistryPtr
newCallback_Admin_pingRegistry(const IceUtil::Handle<T>& instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_pingRegistry<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_pingRegistryPtr
newCallback_Admin_pingRegistry(T* instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_pingRegistry<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_pingRegistry : public Callback_Admin_pingRegistry_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(bool, const CT&);

    Callback_Admin_pingRegistry(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        bool __ret;
        try
        {
            __ret = __proxy->end_pingRegistry(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_pingRegistryPtr
newCallback_Admin_pingRegistry(const IceUtil::Handle<T>& instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_pingRegistry<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_pingRegistryPtr
newCallback_Admin_pingRegistry(T* instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_pingRegistry<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_getRegistryInfo : public Callback_Admin_getRegistryInfo_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::IceGrid::RegistryInfo&);

    CallbackNC_Admin_getRegistryInfo(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::RegistryInfo __ret;
        try
        {
            __ret = __proxy->end_getRegistryInfo(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_getRegistryInfoPtr
newCallback_Admin_getRegistryInfo(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::RegistryInfo&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getRegistryInfo<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_getRegistryInfoPtr
newCallback_Admin_getRegistryInfo(T* instance, void (T::*cb)(const ::IceGrid::RegistryInfo&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getRegistryInfo<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_getRegistryInfo : public Callback_Admin_getRegistryInfo_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::IceGrid::RegistryInfo&, const CT&);

    Callback_Admin_getRegistryInfo(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::RegistryInfo __ret;
        try
        {
            __ret = __proxy->end_getRegistryInfo(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_getRegistryInfoPtr
newCallback_Admin_getRegistryInfo(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::RegistryInfo&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getRegistryInfo<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_getRegistryInfoPtr
newCallback_Admin_getRegistryInfo(T* instance, void (T::*cb)(const ::IceGrid::RegistryInfo&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getRegistryInfo<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_shutdownRegistry : public Callback_Admin_shutdownRegistry_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Admin_shutdownRegistry(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_shutdownRegistry(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)();
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)();
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_shutdownRegistryPtr
newCallback_Admin_shutdownRegistry(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_shutdownRegistry<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_shutdownRegistryPtr
newCallback_Admin_shutdownRegistry(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_shutdownRegistry<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Admin_shutdownRegistryPtr
newCallback_Admin_shutdownRegistry(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_shutdownRegistry<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_shutdownRegistryPtr
newCallback_Admin_shutdownRegistry(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_shutdownRegistry<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_shutdownRegistry : public Callback_Admin_shutdownRegistry_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Admin_shutdownRegistry(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_shutdownRegistry(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_shutdownRegistryPtr
newCallback_Admin_shutdownRegistry(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_shutdownRegistry<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_shutdownRegistryPtr
newCallback_Admin_shutdownRegistry(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_shutdownRegistry<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_shutdownRegistryPtr
newCallback_Admin_shutdownRegistry(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_shutdownRegistry<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_shutdownRegistryPtr
newCallback_Admin_shutdownRegistry(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_shutdownRegistry<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_getAllRegistryNames : public Callback_Admin_getAllRegistryNames_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::Ice::StringSeq&);

    CallbackNC_Admin_getAllRegistryNames(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::Ice::StringSeq __ret;
        try
        {
            __ret = __proxy->end_getAllRegistryNames(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_getAllRegistryNamesPtr
newCallback_Admin_getAllRegistryNames(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::StringSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getAllRegistryNames<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_getAllRegistryNamesPtr
newCallback_Admin_getAllRegistryNames(T* instance, void (T::*cb)(const ::Ice::StringSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getAllRegistryNames<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_getAllRegistryNames : public Callback_Admin_getAllRegistryNames_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::Ice::StringSeq&, const CT&);

    Callback_Admin_getAllRegistryNames(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::Ice::StringSeq __ret;
        try
        {
            __ret = __proxy->end_getAllRegistryNames(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_getAllRegistryNamesPtr
newCallback_Admin_getAllRegistryNames(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::StringSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getAllRegistryNames<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_getAllRegistryNamesPtr
newCallback_Admin_getAllRegistryNames(T* instance, void (T::*cb)(const ::Ice::StringSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getAllRegistryNames<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_shutdown : public Callback_Admin_shutdown_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Admin_shutdown(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Admin_shutdownPtr
newCallback_Admin_shutdown(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_shutdown<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_shutdownPtr
newCallback_Admin_shutdown(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_shutdown<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Admin_shutdownPtr
newCallback_Admin_shutdown(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_shutdown<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_shutdownPtr
newCallback_Admin_shutdown(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_shutdown<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_shutdown : public Callback_Admin_shutdown_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Admin_shutdown(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Admin_shutdownPtr
newCallback_Admin_shutdown(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_shutdown<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_shutdownPtr
newCallback_Admin_shutdown(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_shutdown<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_shutdownPtr
newCallback_Admin_shutdown(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_shutdown<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_shutdownPtr
newCallback_Admin_shutdown(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_shutdown<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Admin_getSliceChecksums : public Callback_Admin_getSliceChecksums_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::Ice::SliceChecksumDict&);

    CallbackNC_Admin_getSliceChecksums(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::Ice::SliceChecksumDict __ret;
        try
        {
            __ret = __proxy->end_getSliceChecksums(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_Admin_getSliceChecksumsPtr
newCallback_Admin_getSliceChecksums(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::SliceChecksumDict&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getSliceChecksums<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Admin_getSliceChecksumsPtr
newCallback_Admin_getSliceChecksums(T* instance, void (T::*cb)(const ::Ice::SliceChecksumDict&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Admin_getSliceChecksums<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Admin_getSliceChecksums : public Callback_Admin_getSliceChecksums_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::Ice::SliceChecksumDict&, const CT&);

    Callback_Admin_getSliceChecksums(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminPrx __proxy = ::IceGrid::AdminPrx::uncheckedCast(__result->getProxy());
        ::Ice::SliceChecksumDict __ret;
        try
        {
            __ret = __proxy->end_getSliceChecksums(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_Admin_getSliceChecksumsPtr
newCallback_Admin_getSliceChecksums(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::SliceChecksumDict&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getSliceChecksums<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Admin_getSliceChecksumsPtr
newCallback_Admin_getSliceChecksums(T* instance, void (T::*cb)(const ::Ice::SliceChecksumDict&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Admin_getSliceChecksums<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_FileIterator_read : public Callback_FileIterator_read_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(bool, const ::Ice::StringSeq&);

    CallbackNC_FileIterator_read(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::FileIteratorPrx __proxy = ::IceGrid::FileIteratorPrx::uncheckedCast(__result->getProxy());
        ::Ice::StringSeq lines;
        bool __ret;
        try
        {
            __ret = __proxy->end_read(lines, __result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, lines);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret, lines);
#endif
        }
    }

    Response response;
};

template<class T> Callback_FileIterator_readPtr
newCallback_FileIterator_read(const IceUtil::Handle<T>& instance, void (T::*cb)(bool, const ::Ice::StringSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_FileIterator_read<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_FileIterator_readPtr
newCallback_FileIterator_read(T* instance, void (T::*cb)(bool, const ::Ice::StringSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_FileIterator_read<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_FileIterator_read : public Callback_FileIterator_read_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(bool, const ::Ice::StringSeq&, const CT&);

    Callback_FileIterator_read(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::FileIteratorPrx __proxy = ::IceGrid::FileIteratorPrx::uncheckedCast(__result->getProxy());
        ::Ice::StringSeq lines;
        bool __ret;
        try
        {
            __ret = __proxy->end_read(lines, __result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, lines, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, lines, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_FileIterator_readPtr
newCallback_FileIterator_read(const IceUtil::Handle<T>& instance, void (T::*cb)(bool, const ::Ice::StringSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_FileIterator_read<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_FileIterator_readPtr
newCallback_FileIterator_read(T* instance, void (T::*cb)(bool, const ::Ice::StringSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_FileIterator_read<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_FileIterator_destroy : public Callback_FileIterator_destroy_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_FileIterator_destroy(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_FileIterator_destroyPtr
newCallback_FileIterator_destroy(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_FileIterator_destroy<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_FileIterator_destroyPtr
newCallback_FileIterator_destroy(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_FileIterator_destroy<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_FileIterator_destroyPtr
newCallback_FileIterator_destroy(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_FileIterator_destroy<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_FileIterator_destroyPtr
newCallback_FileIterator_destroy(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_FileIterator_destroy<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_FileIterator_destroy : public Callback_FileIterator_destroy_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_FileIterator_destroy(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_FileIterator_destroyPtr
newCallback_FileIterator_destroy(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_FileIterator_destroy<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_FileIterator_destroyPtr
newCallback_FileIterator_destroy(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_FileIterator_destroy<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_FileIterator_destroyPtr
newCallback_FileIterator_destroy(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_FileIterator_destroy<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_FileIterator_destroyPtr
newCallback_FileIterator_destroy(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_FileIterator_destroy<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_AdminSession_keepAlive : public Callback_AdminSession_keepAlive_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_AdminSession_keepAlive(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_AdminSession_keepAlivePtr
newCallback_AdminSession_keepAlive(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_keepAlive<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_AdminSession_keepAlivePtr
newCallback_AdminSession_keepAlive(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_keepAlive<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_AdminSession_keepAlivePtr
newCallback_AdminSession_keepAlive(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_keepAlive<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_AdminSession_keepAlivePtr
newCallback_AdminSession_keepAlive(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_keepAlive<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_AdminSession_keepAlive : public Callback_AdminSession_keepAlive_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_AdminSession_keepAlive(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_AdminSession_keepAlivePtr
newCallback_AdminSession_keepAlive(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_keepAlive<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_keepAlivePtr
newCallback_AdminSession_keepAlive(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_keepAlive<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_keepAlivePtr
newCallback_AdminSession_keepAlive(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_keepAlive<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_keepAlivePtr
newCallback_AdminSession_keepAlive(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_keepAlive<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_AdminSession_getAdmin : public Callback_AdminSession_getAdmin_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::IceGrid::AdminPrx&);

    CallbackNC_AdminSession_getAdmin(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::AdminPrx __ret;
        try
        {
            __ret = __proxy->end_getAdmin(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_AdminSession_getAdminPtr
newCallback_AdminSession_getAdmin(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::AdminPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_getAdmin<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_AdminSession_getAdminPtr
newCallback_AdminSession_getAdmin(T* instance, void (T::*cb)(const ::IceGrid::AdminPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_getAdmin<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_AdminSession_getAdmin : public Callback_AdminSession_getAdmin_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::IceGrid::AdminPrx&, const CT&);

    Callback_AdminSession_getAdmin(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::AdminPrx __ret;
        try
        {
            __ret = __proxy->end_getAdmin(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_AdminSession_getAdminPtr
newCallback_AdminSession_getAdmin(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::AdminPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_getAdmin<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_getAdminPtr
newCallback_AdminSession_getAdmin(T* instance, void (T::*cb)(const ::IceGrid::AdminPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_getAdmin<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_AdminSession_getAdminCallbackTemplate : public Callback_AdminSession_getAdminCallbackTemplate_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::Ice::ObjectPrx&);

    CallbackNC_AdminSession_getAdminCallbackTemplate(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        ::Ice::ObjectPrx __ret;
        try
        {
            __ret = __proxy->end_getAdminCallbackTemplate(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_AdminSession_getAdminCallbackTemplatePtr
newCallback_AdminSession_getAdminCallbackTemplate(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::ObjectPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_getAdminCallbackTemplate<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_AdminSession_getAdminCallbackTemplatePtr
newCallback_AdminSession_getAdminCallbackTemplate(T* instance, void (T::*cb)(const ::Ice::ObjectPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_getAdminCallbackTemplate<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_AdminSession_getAdminCallbackTemplate : public Callback_AdminSession_getAdminCallbackTemplate_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::Ice::ObjectPrx&, const CT&);

    Callback_AdminSession_getAdminCallbackTemplate(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        ::Ice::ObjectPrx __ret;
        try
        {
            __ret = __proxy->end_getAdminCallbackTemplate(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_AdminSession_getAdminCallbackTemplatePtr
newCallback_AdminSession_getAdminCallbackTemplate(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::ObjectPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_getAdminCallbackTemplate<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_getAdminCallbackTemplatePtr
newCallback_AdminSession_getAdminCallbackTemplate(T* instance, void (T::*cb)(const ::Ice::ObjectPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_getAdminCallbackTemplate<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_AdminSession_setObservers : public Callback_AdminSession_setObservers_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_AdminSession_setObservers(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_setObservers(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)();
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)();
#endif
        }
    }

    Response response;
};

template<class T> Callback_AdminSession_setObserversPtr
newCallback_AdminSession_setObservers(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_setObservers<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_AdminSession_setObserversPtr
newCallback_AdminSession_setObservers(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_setObservers<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_AdminSession_setObserversPtr
newCallback_AdminSession_setObservers(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_setObservers<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_AdminSession_setObserversPtr
newCallback_AdminSession_setObservers(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_setObservers<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_AdminSession_setObservers : public Callback_AdminSession_setObservers_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_AdminSession_setObservers(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_setObservers(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_AdminSession_setObserversPtr
newCallback_AdminSession_setObservers(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_setObservers<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_setObserversPtr
newCallback_AdminSession_setObservers(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_setObservers<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_setObserversPtr
newCallback_AdminSession_setObservers(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_setObservers<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_setObserversPtr
newCallback_AdminSession_setObservers(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_setObservers<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_AdminSession_setObserversByIdentity : public Callback_AdminSession_setObserversByIdentity_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_AdminSession_setObserversByIdentity(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_setObserversByIdentity(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)();
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)();
#endif
        }
    }

    Response response;
};

template<class T> Callback_AdminSession_setObserversByIdentityPtr
newCallback_AdminSession_setObserversByIdentity(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_setObserversByIdentity<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_AdminSession_setObserversByIdentityPtr
newCallback_AdminSession_setObserversByIdentity(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_setObserversByIdentity<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_AdminSession_setObserversByIdentityPtr
newCallback_AdminSession_setObserversByIdentity(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_setObserversByIdentity<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_AdminSession_setObserversByIdentityPtr
newCallback_AdminSession_setObserversByIdentity(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_setObserversByIdentity<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_AdminSession_setObserversByIdentity : public Callback_AdminSession_setObserversByIdentity_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_AdminSession_setObserversByIdentity(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_setObserversByIdentity(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_AdminSession_setObserversByIdentityPtr
newCallback_AdminSession_setObserversByIdentity(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_setObserversByIdentity<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_setObserversByIdentityPtr
newCallback_AdminSession_setObserversByIdentity(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_setObserversByIdentity<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_setObserversByIdentityPtr
newCallback_AdminSession_setObserversByIdentity(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_setObserversByIdentity<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_setObserversByIdentityPtr
newCallback_AdminSession_setObserversByIdentity(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_setObserversByIdentity<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_AdminSession_startUpdate : public Callback_AdminSession_startUpdate_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(::Ice::Int);

    CallbackNC_AdminSession_startUpdate(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        ::Ice::Int __ret;
        try
        {
            __ret = __proxy->end_startUpdate(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_AdminSession_startUpdatePtr
newCallback_AdminSession_startUpdate(const IceUtil::Handle<T>& instance, void (T::*cb)(::Ice::Int), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_startUpdate<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_AdminSession_startUpdatePtr
newCallback_AdminSession_startUpdate(T* instance, void (T::*cb)(::Ice::Int), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_startUpdate<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_AdminSession_startUpdate : public Callback_AdminSession_startUpdate_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(::Ice::Int, const CT&);

    Callback_AdminSession_startUpdate(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        ::Ice::Int __ret;
        try
        {
            __ret = __proxy->end_startUpdate(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_AdminSession_startUpdatePtr
newCallback_AdminSession_startUpdate(const IceUtil::Handle<T>& instance, void (T::*cb)(::Ice::Int, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_startUpdate<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_startUpdatePtr
newCallback_AdminSession_startUpdate(T* instance, void (T::*cb)(::Ice::Int, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_startUpdate<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_AdminSession_finishUpdate : public Callback_AdminSession_finishUpdate_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_AdminSession_finishUpdate(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_finishUpdate(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)();
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)();
#endif
        }
    }

    Response response;
};

template<class T> Callback_AdminSession_finishUpdatePtr
newCallback_AdminSession_finishUpdate(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_finishUpdate<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_AdminSession_finishUpdatePtr
newCallback_AdminSession_finishUpdate(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_finishUpdate<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_AdminSession_finishUpdatePtr
newCallback_AdminSession_finishUpdate(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_finishUpdate<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_AdminSession_finishUpdatePtr
newCallback_AdminSession_finishUpdate(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_finishUpdate<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_AdminSession_finishUpdate : public Callback_AdminSession_finishUpdate_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_AdminSession_finishUpdate(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        try
        {
            __proxy->end_finishUpdate(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_AdminSession_finishUpdatePtr
newCallback_AdminSession_finishUpdate(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_finishUpdate<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_finishUpdatePtr
newCallback_AdminSession_finishUpdate(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_finishUpdate<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_finishUpdatePtr
newCallback_AdminSession_finishUpdate(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_finishUpdate<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_finishUpdatePtr
newCallback_AdminSession_finishUpdate(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_finishUpdate<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_AdminSession_getReplicaName : public Callback_AdminSession_getReplicaName_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::std::string&);

    CallbackNC_AdminSession_getReplicaName(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        ::std::string __ret;
        try
        {
            __ret = __proxy->end_getReplicaName(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_AdminSession_getReplicaNamePtr
newCallback_AdminSession_getReplicaName(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::std::string&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_getReplicaName<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_AdminSession_getReplicaNamePtr
newCallback_AdminSession_getReplicaName(T* instance, void (T::*cb)(const ::std::string&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_getReplicaName<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_AdminSession_getReplicaName : public Callback_AdminSession_getReplicaName_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::std::string&, const CT&);

    Callback_AdminSession_getReplicaName(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        ::std::string __ret;
        try
        {
            __ret = __proxy->end_getReplicaName(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_AdminSession_getReplicaNamePtr
newCallback_AdminSession_getReplicaName(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::std::string&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_getReplicaName<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_getReplicaNamePtr
newCallback_AdminSession_getReplicaName(T* instance, void (T::*cb)(const ::std::string&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_getReplicaName<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_AdminSession_openServerLog : public Callback_AdminSession_openServerLog_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::IceGrid::FileIteratorPrx&);

    CallbackNC_AdminSession_openServerLog(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::FileIteratorPrx __ret;
        try
        {
            __ret = __proxy->end_openServerLog(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_AdminSession_openServerLogPtr
newCallback_AdminSession_openServerLog(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_openServerLog<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_AdminSession_openServerLogPtr
newCallback_AdminSession_openServerLog(T* instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_openServerLog<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_AdminSession_openServerLog : public Callback_AdminSession_openServerLog_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::IceGrid::FileIteratorPrx&, const CT&);

    Callback_AdminSession_openServerLog(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::FileIteratorPrx __ret;
        try
        {
            __ret = __proxy->end_openServerLog(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_AdminSession_openServerLogPtr
newCallback_AdminSession_openServerLog(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_openServerLog<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_openServerLogPtr
newCallback_AdminSession_openServerLog(T* instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_openServerLog<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_AdminSession_openServerStdErr : public Callback_AdminSession_openServerStdErr_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::IceGrid::FileIteratorPrx&);

    CallbackNC_AdminSession_openServerStdErr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::FileIteratorPrx __ret;
        try
        {
            __ret = __proxy->end_openServerStdErr(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_AdminSession_openServerStdErrPtr
newCallback_AdminSession_openServerStdErr(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_openServerStdErr<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_AdminSession_openServerStdErrPtr
newCallback_AdminSession_openServerStdErr(T* instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_openServerStdErr<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_AdminSession_openServerStdErr : public Callback_AdminSession_openServerStdErr_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::IceGrid::FileIteratorPrx&, const CT&);

    Callback_AdminSession_openServerStdErr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::FileIteratorPrx __ret;
        try
        {
            __ret = __proxy->end_openServerStdErr(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_AdminSession_openServerStdErrPtr
newCallback_AdminSession_openServerStdErr(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_openServerStdErr<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_openServerStdErrPtr
newCallback_AdminSession_openServerStdErr(T* instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_openServerStdErr<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_AdminSession_openServerStdOut : public Callback_AdminSession_openServerStdOut_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::IceGrid::FileIteratorPrx&);

    CallbackNC_AdminSession_openServerStdOut(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::FileIteratorPrx __ret;
        try
        {
            __ret = __proxy->end_openServerStdOut(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_AdminSession_openServerStdOutPtr
newCallback_AdminSession_openServerStdOut(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_openServerStdOut<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_AdminSession_openServerStdOutPtr
newCallback_AdminSession_openServerStdOut(T* instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_openServerStdOut<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_AdminSession_openServerStdOut : public Callback_AdminSession_openServerStdOut_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::IceGrid::FileIteratorPrx&, const CT&);

    Callback_AdminSession_openServerStdOut(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::FileIteratorPrx __ret;
        try
        {
            __ret = __proxy->end_openServerStdOut(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_AdminSession_openServerStdOutPtr
newCallback_AdminSession_openServerStdOut(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_openServerStdOut<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_openServerStdOutPtr
newCallback_AdminSession_openServerStdOut(T* instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_openServerStdOut<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_AdminSession_openNodeStdErr : public Callback_AdminSession_openNodeStdErr_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::IceGrid::FileIteratorPrx&);

    CallbackNC_AdminSession_openNodeStdErr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::FileIteratorPrx __ret;
        try
        {
            __ret = __proxy->end_openNodeStdErr(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_AdminSession_openNodeStdErrPtr
newCallback_AdminSession_openNodeStdErr(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_openNodeStdErr<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_AdminSession_openNodeStdErrPtr
newCallback_AdminSession_openNodeStdErr(T* instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_openNodeStdErr<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_AdminSession_openNodeStdErr : public Callback_AdminSession_openNodeStdErr_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::IceGrid::FileIteratorPrx&, const CT&);

    Callback_AdminSession_openNodeStdErr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::FileIteratorPrx __ret;
        try
        {
            __ret = __proxy->end_openNodeStdErr(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_AdminSession_openNodeStdErrPtr
newCallback_AdminSession_openNodeStdErr(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_openNodeStdErr<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_openNodeStdErrPtr
newCallback_AdminSession_openNodeStdErr(T* instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_openNodeStdErr<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_AdminSession_openNodeStdOut : public Callback_AdminSession_openNodeStdOut_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::IceGrid::FileIteratorPrx&);

    CallbackNC_AdminSession_openNodeStdOut(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::FileIteratorPrx __ret;
        try
        {
            __ret = __proxy->end_openNodeStdOut(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_AdminSession_openNodeStdOutPtr
newCallback_AdminSession_openNodeStdOut(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_openNodeStdOut<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_AdminSession_openNodeStdOutPtr
newCallback_AdminSession_openNodeStdOut(T* instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_openNodeStdOut<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_AdminSession_openNodeStdOut : public Callback_AdminSession_openNodeStdOut_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::IceGrid::FileIteratorPrx&, const CT&);

    Callback_AdminSession_openNodeStdOut(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::FileIteratorPrx __ret;
        try
        {
            __ret = __proxy->end_openNodeStdOut(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_AdminSession_openNodeStdOutPtr
newCallback_AdminSession_openNodeStdOut(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_openNodeStdOut<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_openNodeStdOutPtr
newCallback_AdminSession_openNodeStdOut(T* instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_openNodeStdOut<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_AdminSession_openRegistryStdErr : public Callback_AdminSession_openRegistryStdErr_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::IceGrid::FileIteratorPrx&);

    CallbackNC_AdminSession_openRegistryStdErr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::FileIteratorPrx __ret;
        try
        {
            __ret = __proxy->end_openRegistryStdErr(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_AdminSession_openRegistryStdErrPtr
newCallback_AdminSession_openRegistryStdErr(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_openRegistryStdErr<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_AdminSession_openRegistryStdErrPtr
newCallback_AdminSession_openRegistryStdErr(T* instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_openRegistryStdErr<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_AdminSession_openRegistryStdErr : public Callback_AdminSession_openRegistryStdErr_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::IceGrid::FileIteratorPrx&, const CT&);

    Callback_AdminSession_openRegistryStdErr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::FileIteratorPrx __ret;
        try
        {
            __ret = __proxy->end_openRegistryStdErr(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_AdminSession_openRegistryStdErrPtr
newCallback_AdminSession_openRegistryStdErr(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_openRegistryStdErr<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_openRegistryStdErrPtr
newCallback_AdminSession_openRegistryStdErr(T* instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_openRegistryStdErr<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_AdminSession_openRegistryStdOut : public Callback_AdminSession_openRegistryStdOut_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::IceGrid::FileIteratorPrx&);

    CallbackNC_AdminSession_openRegistryStdOut(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::FileIteratorPrx __ret;
        try
        {
            __ret = __proxy->end_openRegistryStdOut(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret);
#else
            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
#endif
        }
    }

    Response response;
};

template<class T> Callback_AdminSession_openRegistryStdOutPtr
newCallback_AdminSession_openRegistryStdOut(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_openRegistryStdOut<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_AdminSession_openRegistryStdOutPtr
newCallback_AdminSession_openRegistryStdOut(T* instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_AdminSession_openRegistryStdOut<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_AdminSession_openRegistryStdOut : public Callback_AdminSession_openRegistryStdOut_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::IceGrid::FileIteratorPrx&, const CT&);

    Callback_AdminSession_openRegistryStdOut(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
    {
    }

    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::IceGrid::AdminSessionPrx __proxy = ::IceGrid::AdminSessionPrx::uncheckedCast(__result->getProxy());
        ::IceGrid::FileIteratorPrx __ret;
        try
        {
            __ret = __proxy->end_openRegistryStdOut(__result);
        }
        catch(::Ice::Exception& ex)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            __exception(__result, ex);
#else
            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
#endif
            return;
        }
        if(response)
        {
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
            (callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#else
            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
#endif
        }
    }

    Response response;
};

template<class T, typename CT> Callback_AdminSession_openRegistryStdOutPtr
newCallback_AdminSession_openRegistryStdOut(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_openRegistryStdOut<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_AdminSession_openRegistryStdOutPtr
newCallback_AdminSession_openRegistryStdOut(T* instance, void (T::*cb)(const ::IceGrid::FileIteratorPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_AdminSession_openRegistryStdOut<T, CT>(instance, cb, excb, sentcb);
}

}

#endif
