clientmaster.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 `ClientMaster.ice'

#include <ClientMaster.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 __ClientMaster__FileObjectsManager__getFileObjectStorageInformation_name = "getFileObjectStorageInformation";

static const ::std::string __ClientMaster__FileObjectsManager__setFileObjectStorageInformation_name = "setFileObjectStorageInformation";

static const ::std::string __ClientMaster__FileObjectsManager__getStorageNodes_name = "getStorageNodes";

static const ::std::string __ClientMaster__FileObjectsManager__getFSList_name = "getFSList";

static const ::std::string __ClientMaster__FileObjectsManager__createFolder_name = "createFolder";

static const ::std::string __ClientMaster__FileObjectsManager__deleteFolder_name = "deleteFolder";

static const ::std::string __ClientMaster__FileObjectsManager__deleteFile_name = "deleteFile";

void
IceInternal::incRef(::ClientMaster::FileObjectsManager* p)
{
    p->__incRef();
}

void
IceInternal::decRef(::ClientMaster::FileObjectsManager* p)
{
    p->__decRef();
}

void
IceInternal::incRef(::IceProxy::ClientMaster::FileObjectsManager* p)
{
    p->__incRef();
}

void
IceInternal::decRef(::IceProxy::ClientMaster::FileObjectsManager* p)
{
    p->__decRef();
}

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

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

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

bool
ClientMaster::FileBlock::operator==(const FileBlock& __rhs) const
{
    return !operator!=(__rhs);
}

bool
ClientMaster::FileBlock::operator!=(const FileBlock& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(blockID != __rhs.blockID)
    {
        return true;
    }
    if(indexID != __rhs.indexID)
    {
        return true;
    }
    if(IPs != __rhs.IPs)
    {
        return true;
    }
    return false;
}

bool
ClientMaster::FileBlock::operator<(const FileBlock& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(blockID < __rhs.blockID)
    {
        return true;
    }
    else if(__rhs.blockID < blockID)
    {
        return false;
    }
    if(indexID < __rhs.indexID)
    {
        return true;
    }
    else if(__rhs.indexID < indexID)
    {
        return false;
    }
    if(IPs < __rhs.IPs)
    {
        return true;
    }
    else if(__rhs.IPs < IPs)
    {
        return false;
    }
    return false;
}

void
ClientMaster::FileBlock::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(blockID);
    __os->write(indexID);
    if(IPs.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        __os->write(&IPs[0], &IPs[0] + IPs.size());
    }
}

void
ClientMaster::FileBlock::__read(::IceInternal::BasicStream* __is)
{
    __is->read(blockID);
    __is->read(indexID);
    __is->read(IPs);
}

void
ClientMaster::__write(::IceInternal::BasicStream* __os, const ::ClientMaster::FileBlock* begin, const ::ClientMaster::FileBlock* end, ::ClientMaster::__U__FileObject)
{
    ::Ice::Int size = static_cast< ::Ice::Int>(end - begin);
    __os->writeSize(size);
    for(int i = 0; i < size; ++i)
    {
        begin[i].__write(__os);
    }
}

void
ClientMaster::__read(::IceInternal::BasicStream* __is, ::ClientMaster::FileObject& v, ::ClientMaster::__U__FileObject)
{
    ::Ice::Int sz;
    __is->readSize(sz);
    __is->startSeq(sz, 10);
    v.resize(sz);
    for(int i = 0; i < sz; ++i)
    {
        v[i].__read(__is);
        __is->checkSeq();
        __is->endElement();
    }
    __is->endSeq(sz);
}

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

bool
ClientMaster::__usesClasses(const FileObjectsManagerPtr& p)
{
    return p->__usesClasses();
}

void
ClientMaster::__decRefUnsafe(const FileObjectsManagerPtr& p)
{
    p->__decRefUnsafe();
}

void
ClientMaster::__clearHandleUnsafe(FileObjectsManagerPtr& p)
{
    p.__clearHandleUnsafe();
}

bool
IceProxy::ClientMaster::FileObjectsManager::getFileObjectStorageInformation(const ::std::string& fileName, ::ClientMaster::FileObject& fileObj, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__ClientMaster__FileObjectsManager__getFileObjectStorageInformation_name);
            __delBase = __getDelegate();
            ::IceDelegate::ClientMaster::FileObjectsManager* __del = dynamic_cast< ::IceDelegate::ClientMaster::FileObjectsManager*>(__delBase.get());
            return __del->getFileObjectStorageInformation(fileName, fileObj, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, __cnt);
        }
    }
}

bool
IceProxy::ClientMaster::FileObjectsManager::setFileObjectStorageInformation(const ::std::string& fileName, const ::ClientMaster::FileObject& fileObj, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__ClientMaster__FileObjectsManager__setFileObjectStorageInformation_name);
            __delBase = __getDelegate();
            ::IceDelegate::ClientMaster::FileObjectsManager* __del = dynamic_cast< ::IceDelegate::ClientMaster::FileObjectsManager*>(__delBase.get());
            return __del->setFileObjectStorageInformation(fileName, fileObj, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, __cnt);
        }
    }
}

::ClientMaster::desIPList
IceProxy::ClientMaster::FileObjectsManager::getStorageNodes(const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__ClientMaster__FileObjectsManager__getStorageNodes_name);
            __delBase = __getDelegate();
            ::IceDelegate::ClientMaster::FileObjectsManager* __del = dynamic_cast< ::IceDelegate::ClientMaster::FileObjectsManager*>(__delBase.get());
            return __del->getStorageNodes(__ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, __cnt);
        }
    }
}

::ClientMaster::list
IceProxy::ClientMaster::FileObjectsManager::getFSList(const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__ClientMaster__FileObjectsManager__getFSList_name);
            __delBase = __getDelegate();
            ::IceDelegate::ClientMaster::FileObjectsManager* __del = dynamic_cast< ::IceDelegate::ClientMaster::FileObjectsManager*>(__delBase.get());
            return __del->getFSList(__ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, __cnt);
        }
    }
}

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

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

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

const ::std::string&
IceProxy::ClientMaster::FileObjectsManager::ice_staticId()
{
    return ::ClientMaster::FileObjectsManager::ice_staticId();
}

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

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

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

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