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

#include <ClientClerk.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 __ClientClerk__FileIOManager__writeFile_name = "writeFile";

static const ::std::string __ClientClerk__FileIOManager__readFile_name = "readFile";

void
IceInternal::incRef(::ClientClerk::FileIOManager* p)
{
    p->__incRef();
}

void
IceInternal::decRef(::ClientClerk::FileIOManager* p)
{
    p->__decRef();
}

void
IceInternal::incRef(::IceProxy::ClientClerk::FileIOManager* p)
{
    p->__incRef();
}

void
IceInternal::decRef(::IceProxy::ClientClerk::FileIOManager* p)
{
    p->__decRef();
}

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

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

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

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

bool
ClientClerk::__usesClasses(const FileIOManagerPtr& p)
{
    return p->__usesClasses();
}

void
ClientClerk::__decRefUnsafe(const FileIOManagerPtr& p)
{
    p->__decRefUnsafe();
}

void
ClientClerk::__clearHandleUnsafe(FileIOManagerPtr& p)
{
    p.__clearHandleUnsafe();
}

bool
IceProxy::ClientClerk::FileIOManager::writeFile(const ::std::string& blockIndex, const ::ClientClerk::BinaryData& data, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__ClientClerk__FileIOManager__writeFile_name);
            __delBase = __getDelegate();
            ::IceDelegate::ClientClerk::FileIOManager* __del = dynamic_cast< ::IceDelegate::ClientClerk::FileIOManager*>(__delBase.get());
            return __del->writeFile(blockIndex, data, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, __cnt);
        }
    }
}

bool
IceProxy::ClientClerk::FileIOManager::readFile(const ::std::string& blockIndex, ::ClientClerk::BinaryData& data, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__ClientClerk__FileIOManager__readFile_name);
            __delBase = __getDelegate();
            ::IceDelegate::ClientClerk::FileIOManager* __del = dynamic_cast< ::IceDelegate::ClientClerk::FileIOManager*>(__delBase.get());
            return __del->readFile(blockIndex, data, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, __cnt);
        }
    }
}

const ::std::string&
IceProxy::ClientClerk::FileIOManager::ice_staticId()
{
    return ::ClientClerk::FileIOManager::ice_staticId();
}

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

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

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

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

bool
IceProxy::ClientClerk::operator<(const ::IceProxy::ClientClerk::FileIOManager& l, const ::IceProxy::ClientClerk::FileIOManager& r)
{
    return static_cast<const ::IceProxy::Ice::Object&>(l) < static_cast<const ::IceProxy::Ice::Object&>(r);
}

bool
IceProxy::ClientClerk::operator<=(const ::IceProxy::ClientClerk::FileIOManager& l, const ::IceProxy::ClientClerk::FileIOManager& r)
{
    return l < r || l == r;
}

bool
IceProxy::ClientClerk::operator>(const ::IceProxy::ClientClerk::FileIOManager& l, const ::IceProxy::ClientClerk::FileIOManager& r)
{
    return !(l < r) && !(l == r);
}

bool
IceProxy::ClientClerk::operator>=(const ::IceProxy::ClientClerk::FileIOManager& l, const ::IceProxy::ClientClerk::FileIOManager& r)
{
    return !(l < r);
}

bool
IceDelegateM::ClientClerk::FileIOManager::writeFile(const ::std::string& blockIndex, const ::ClientClerk::BinaryData& data, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__connection.get(), __reference.get(), __ClientClerk__FileIOManager__writeFile_name, ::Ice::Normal, __context, __compress);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(blockIndex);
        if(data.size() == 0)
        {
            __os->writeSize(0);
        }
        else
        {
            __os->write(&data[0], &data[0] + data.size());
        }
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    try
    {
        ::IceInternal::BasicStream* __is = __og.is();
        if(!__ok)
        {
            try
            {
                __is->throwException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
            }
        }
        bool __ret;
        __is->read(__ret);
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

bool
IceDelegateM::ClientClerk::FileIOManager::readFile(const ::std::string& blockIndex, ::ClientClerk::BinaryData& data, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__connection.get(), __reference.get(), __ClientClerk__FileIOManager__readFile_name, ::Ice::Normal, __context, __compress);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(blockIndex);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    try
    {
        ::IceInternal::BasicStream* __is = __og.is();
        if(!__ok)
        {
            try
            {
                __is->throwException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
            }
        }
        bool __ret;
        ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> ___data;
        __is->read(___data);
        ::std::vector< ::Ice::Byte>(___data.first, ___data.second).swap(data);
        __is->read(__ret);
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}