cluster.cpp

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

}

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

static const ::std::string __Cluster__ClerkCallBack_ids[2] =
{
    "::Cluster::ClerkCallBack",
    "::Ice::Object"
};

bool
Cluster::ClerkCallBack::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Cluster__ClerkCallBack_ids, __Cluster__ClerkCallBack_ids + 2, _s);
}

::std::vector< ::std::string>
Cluster::ClerkCallBack::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Cluster__ClerkCallBack_ids[0], &__Cluster__ClerkCallBack_ids[2]);
}

const ::std::string&
Cluster::ClerkCallBack::ice_id(const ::Ice::Current&) const
{
    return __Cluster__ClerkCallBack_ids[0];
}

const ::std::string&
Cluster::ClerkCallBack::ice_staticId()
{
    return __Cluster__ClerkCallBack_ids[0];
}

::IceInternal::DispatchStatus
Cluster::ClerkCallBack::___reportState(::IceInternal::Incoming&__inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Idempotent, __current.mode);
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Cluster::HeartBeatMessage hbMsg;
    reportState(hbMsg, __current);
    hbMsg.__write(__os);
    return ::IceInternal::DispatchOK;
}

::IceInternal::DispatchStatus
Cluster::ClerkCallBack::___replicaCopy(::IceInternal::Incoming&__inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Cluster::ReplicaInfo repInfo;
    repInfo.__read(__is);
    bool __ret = replicaCopy(repInfo, __current);
    __os->write(__ret);
    return ::IceInternal::DispatchOK;
}

::IceInternal::DispatchStatus
Cluster::ClerkCallBack::___replicaDelete(::IceInternal::Incoming&__inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::std::string replicaID;
    __is->read(replicaID);
    bool __ret = replicaDelete(replicaID, __current);
    __os->write(__ret);
    return ::IceInternal::DispatchOK;
}

static ::std::string __Cluster__ClerkCallBack_all[] =
{
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping",
    "replicaCopy",
    "replicaDelete",
    "reportState"
};

::IceInternal::DispatchStatus
Cluster::ClerkCallBack::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__Cluster__ClerkCallBack_all, __Cluster__ClerkCallBack_all + 7, current.operation);
    if(r.first == r.second)
    {
        return ::IceInternal::DispatchOperationNotExist;
    }

    switch(r.first - __Cluster__ClerkCallBack_all)
    {
        case 0:
        {
            return ___ice_id(in, current);
        }
        case 1:
        {
            return ___ice_ids(in, current);
        }
        case 2:
        {
            return ___ice_isA(in, current);
        }
        case 3:
        {
            return ___ice_ping(in, current);
        }
        case 4:
        {
            return ___replicaCopy(in, current);
        }
        case 5:
        {
            return ___replicaDelete(in, current);
        }
        case 6:
        {
            return ___reportState(in, current);
        }
    }

    assert(false);
    return ::IceInternal::DispatchOperationNotExist;
}

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

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

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

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

void 
Cluster::__patch__ClerkCallBackPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::Cluster::ClerkCallBackPtr* p = static_cast< ::Cluster::ClerkCallBackPtr*>(__addr);
    assert(p);
    *p = ::Cluster::ClerkCallBackPtr::dynamicCast(v);
    if(v && !*p)
    {
        ::Ice::UnexpectedObjectException e(__FILE__, __LINE__);
        e.type = v->ice_id();
        e.expectedType = ::Cluster::ClerkCallBack::ice_staticId();
        throw e;
    }
}

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

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

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

bool
Cluster::operator<=(const ::Cluster::ClerkCallBack& l, const ::Cluster::ClerkCallBack& r)
{
    return l < r || l == r;
}

bool
Cluster::operator>(const ::Cluster::ClerkCallBack& l, const ::Cluster::ClerkCallBack& r)
{
    return !(l < r) && !(l == r);
}

bool
Cluster::operator>=(const ::Cluster::ClerkCallBack& l, const ::Cluster::ClerkCallBack& r)
{
    return !(l < r);
}

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

static const ::std::string __Cluster__ClusterMessenger_ids[2] =
{
    "::Cluster::ClusterMessenger",
    "::Ice::Object"
};

bool
Cluster::ClusterMessenger::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Cluster__ClusterMessenger_ids, __Cluster__ClusterMessenger_ids + 2, _s);
}

::std::vector< ::std::string>
Cluster::ClusterMessenger::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Cluster__ClusterMessenger_ids[0], &__Cluster__ClusterMessenger_ids[2]);
}

const ::std::string&
Cluster::ClusterMessenger::ice_id(const ::Ice::Current&) const
{
    return __Cluster__ClusterMessenger_ids[0];
}

const ::std::string&
Cluster::ClusterMessenger::ice_staticId()
{
    return __Cluster__ClusterMessenger_ids[0];
}

::IceInternal::DispatchStatus
Cluster::ClusterMessenger::___clerkCallBackRegister(::IceInternal::Incoming&__inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    ::std::string clerkIP;
    ::Cluster::ClerkCallBackPrx clerkcb;
    __is->read(clerkIP);
    ::Cluster::__read(__is, clerkcb);
    clerkCallBackRegister(clerkIP, clerkcb, __current);
    return ::IceInternal::DispatchOK;
}

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

::IceInternal::DispatchStatus
Cluster::ClusterMessenger::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__Cluster__ClusterMessenger_all, __Cluster__ClusterMessenger_all + 5, current.operation);
    if(r.first == r.second)
    {
        return ::IceInternal::DispatchOperationNotExist;
    }

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

    assert(false);
    return ::IceInternal::DispatchOperationNotExist;
}

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

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

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

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

void 
Cluster::__patch__ClusterMessengerPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::Cluster::ClusterMessengerPtr* p = static_cast< ::Cluster::ClusterMessengerPtr*>(__addr);
    assert(p);
    *p = ::Cluster::ClusterMessengerPtr::dynamicCast(v);
    if(v && !*p)
    {
        ::Ice::UnexpectedObjectException e(__FILE__, __LINE__);
        e.type = v->ice_id();
        e.expectedType = ::Cluster::ClusterMessenger::ice_staticId();
        throw e;
    }
}

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

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

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

bool
Cluster::operator<=(const ::Cluster::ClusterMessenger& l, const ::Cluster::ClusterMessenger& r)
{
    return l < r || l == r;
}

bool
Cluster::operator>(const ::Cluster::ClusterMessenger& l, const ::Cluster::ClusterMessenger& r)
{
    return !(l < r) && !(l == r);
}

bool
Cluster::operator>=(const ::Cluster::ClusterMessenger& l, const ::Cluster::ClusterMessenger& r)
{
    return !(l < r);
}