cluster.cpp

GiPS是一个面向数据密集型应用的分布式文件系统

// **********************************************************************
//
// Copyright (c) 2003-2007 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.2.1
// Generated from file `Cluster.ice'

#include <Cluster.h>
#include <Ice/LocalException.h>
#include <Ice/ObjectFactory.h>
#include <Ice/BasicStream.h>
#include <Ice/Object.h>
#include <IceUtil/Iterator.h>
#include <IceUtil/ScopedArray.h>

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

static const ::std::string __Cluster__ClerkCallBack__reportState_name = "reportState";

static const ::std::string __Cluster__ClerkCallBack__replicaCopy_name = "replicaCopy";

static const ::std::string __Cluster__ClerkCallBack__replicaDelete_name = "replicaDelete";

static const ::std::string __Cluster__ClusterMessenger__clerkCallBackRegister_name = "clerkCallBackRegister";

void
IceInternal::incRef(::Cluster::ClerkCallBack* p)
{
    p->__incRef();
}

void
IceInternal::decRef(::Cluster::ClerkCallBack* p)
{
    p->__decRef();
}

void
IceInternal::incRef(::IceProxy::Cluster::ClerkCallBack* p)
{
    p->__incRef();
}

void
IceInternal::decRef(::IceProxy::Cluster::ClerkCallBack* p)
{
    p->__decRef();
}

void
IceInternal::incRef(::Cluster::ClusterMessenger* p)
{
    p->__incRef();
}

void
IceInternal::decRef(::Cluster::ClusterMessenger* p)
{
    p->__decRef();
}

void
IceInternal::incRef(::IceProxy::Cluster::ClusterMessenger* p)
{
    p->__incRef();
}

void
IceInternal::decRef(::IceProxy::Cluster::ClusterMessenger* p)
{
    p->__decRef();
}

void
Cluster::__write(::IceInternal::BasicStream* __os, const ::Cluster::ClerkCallBackPrx& v)
{
    __os->write(::Ice::ObjectPrx(v));
}

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

void
Cluster::__write(::IceInternal::BasicStream* __os, const ::Cluster::ClerkCallBackPtr& v)
{
    __os->write(::Ice::ObjectPtr(v));
}

void
Cluster::__write(::IceInternal::BasicStream* __os, const ::Cluster::ClusterMessengerPrx& v)
{
    __os->write(::Ice::ObjectPrx(v));
}

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

void
Cluster::__write(::IceInternal::BasicStream* __os, const ::Cluster::ClusterMessengerPtr& v)
{
    __os->write(::Ice::ObjectPtr(v));
}

bool
Cluster::HeartBeatMessage::operator==(const HeartBeatMessage& __rhs) const
{
    return !operator!=(__rhs);
}

bool
Cluster::HeartBeatMessage::operator!=(const HeartBeatMessage& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(ip != __rhs.ip)
    {
        return true;
    }
    if(blockNum != __rhs.blockNum)
    {
        return true;
    }
    return false;
}

bool
Cluster::HeartBeatMessage::operator<(const HeartBeatMessage& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(ip < __rhs.ip)
    {
        return true;
    }
    else if(__rhs.ip < ip)
    {
        return false;
    }
    if(blockNum < __rhs.blockNum)
    {
        return true;
    }
    else if(__rhs.blockNum < blockNum)
    {
        return false;
    }
    return false;
}

void
Cluster::HeartBeatMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(ip);
    __os->write(blockNum);
}

void
Cluster::HeartBeatMessage::__read(::IceInternal::BasicStream* __is)
{
    __is->read(ip);
    __is->read(blockNum);
}

bool
Cluster::ReplicaInfo::operator==(const ReplicaInfo& __rhs) const
{
    return !operator!=(__rhs);
}

bool
Cluster::ReplicaInfo::operator!=(const ReplicaInfo& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(replicaID != __rhs.replicaID)
    {
        return true;
    }
    if(clerkIP != __rhs.clerkIP)
    {
        return true;
    }
    return false;
}

bool
Cluster::ReplicaInfo::operator<(const ReplicaInfo& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(replicaID < __rhs.replicaID)
    {
        return true;
    }
    else if(__rhs.replicaID < replicaID)
    {
        return false;
    }
    if(clerkIP < __rhs.clerkIP)
    {
        return true;
    }
    else if(__rhs.clerkIP < clerkIP)
    {
        return false;
    }
    return false;
}

void
Cluster::ReplicaInfo::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(replicaID);
    __os->write(clerkIP);
}

void
Cluster::ReplicaInfo::__read(::IceInternal::BasicStream* __is)
{
    __is->read(replicaID);
    __is->read(clerkIP);
}

void
Cluster::__addObject(const ClerkCallBackPtr& p, ::IceInternal::GCCountMap& c)
{
    p->__addObject(c);
}

bool
Cluster::__usesClasses(const ClerkCallBackPtr& p)
{
    return p->__usesClasses();
}

void
Cluster::__decRefUnsafe(const ClerkCallBackPtr& p)
{
    p->__decRefUnsafe();
}

void
Cluster::__clearHandleUnsafe(ClerkCallBackPtr& p)
{
    p.__clearHandleUnsafe();
}

void
Cluster::__write(::IceInternal::BasicStream* __os, const ::Cluster::ClerkMap& v, ::Cluster::__U__ClerkMap)
{
    __os->writeSize(::Ice::Int(v.size()));
    ::Cluster::ClerkMap::const_iterator p;
    for(p = v.begin(); p != v.end(); ++p)
    {
        __os->write(p->first);
        ::Cluster::__write(__os, p->second);
    }
}

void
Cluster::__read(::IceInternal::BasicStream* __is, ::Cluster::ClerkMap& v, ::Cluster::__U__ClerkMap)
{
    ::Ice::Int sz;
    __is->readSize(sz);
    while(sz--)
    {
        ::std::pair<const  ::std::string, ::Cluster::ClerkCallBackPrx> pair;
        __is->read(const_cast< ::std::string&>(pair.first));
        ::Cluster::ClerkMap::iterator __i = v.insert(v.end(), pair);
        ::Cluster::__read(__is, __i->second);
    }
}

void
Cluster::__addObject(const ClusterMessengerPtr& p, ::IceInternal::GCCountMap& c)
{
    p->__addObject(c);
}

bool
Cluster::__usesClasses(const ClusterMessengerPtr& p)
{
    return p->__usesClasses();
}

void
Cluster::__decRefUnsafe(const ClusterMessengerPtr& p)
{
    p->__decRefUnsafe();
}

void
Cluster::__clearHandleUnsafe(ClusterMessengerPtr& p)
{
    p.__clearHandleUnsafe();
}

void
IceProxy::Cluster::ClerkCallBack::reportState(::Cluster::HeartBeatMessage& hbMsg, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__Cluster__ClerkCallBack__reportState_name);
            __delBase = __getDelegate();
            ::IceDelegate::Cluster::ClerkCallBack* __del = dynamic_cast< ::IceDelegate::Cluster::ClerkCallBack*>(__delBase.get());
            __del->reportState(hbMsg, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapperRelaxed(__delBase, __ex, __cnt);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, __cnt);
        }
    }
}

bool
IceProxy::Cluster::ClerkCallBack::replicaCopy(const ::Cluster::ReplicaInfo& repInfo, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__Cluster__ClerkCallBack__replicaCopy_name);
            __delBase = __getDelegate();
            ::IceDelegate::Cluster::ClerkCallBack* __del = dynamic_cast< ::IceDelegate::Cluster::ClerkCallBack*>(__delBase.get());
            return __del->replicaCopy(repInfo, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, __cnt);
        }
    }
}

bool
IceProxy::Cluster::ClerkCallBack::replicaDelete(const ::std::string& replicaID, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__Cluster__ClerkCallBack__replicaDelete_name);
            __delBase = __getDelegate();
            ::IceDelegate::Cluster::ClerkCallBack* __del = dynamic_cast< ::IceDelegate::Cluster::ClerkCallBack*>(__delBase.get());
            return __del->replicaDelete(replicaID, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, __cnt);
        }
    }
}

const ::std::string&