clientmaster.cpp

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

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 l < r || l == r;
}

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

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

bool
IceDelegateM::ClientMaster::FileObjectsManager::getFileObjectStorageInformation(const ::std::string& fileName, ::ClientMaster::FileObject& fileObj, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__connection.get(), __reference.get(), __ClientMaster__FileObjectsManager__getFileObjectStorageInformation_name, ::Ice::Normal, __context, __compress);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(fileName);
    }
    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;
        ::ClientMaster::__read(__is, fileObj, ::ClientMaster::__U__FileObject());
        __is->read(__ret);
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

bool
IceDelegateM::ClientMaster::FileObjectsManager::setFileObjectStorageInformation(const ::std::string& fileName, const ::ClientMaster::FileObject& fileObj, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__connection.get(), __reference.get(), __ClientMaster__FileObjectsManager__setFileObjectStorageInformation_name, ::Ice::Normal, __context, __compress);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(fileName);
        if(fileObj.size() == 0)
        {
            __os->writeSize(0);
        }
        else
        {
            ::ClientMaster::__write(__os, &fileObj[0], &fileObj[0] + fileObj.size(), ::ClientMaster::__U__FileObject());
        }
    }
    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);
    }
}

::ClientMaster::desIPList
IceDelegateM::ClientMaster::FileObjectsManager::getStorageNodes(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__connection.get(), __reference.get(), __ClientMaster__FileObjectsManager__getStorageNodes_name, ::Ice::Normal, __context, __compress);
    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());
            }
        }
        ::ClientMaster::desIPList __ret;
        __is->read(__ret);
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::ClientMaster::list
IceDelegateM::ClientMaster::FileObjectsManager::getFSList(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__connection.get(), __reference.get(), __ClientMaster__FileObjectsManager__getFSList_name, ::Ice::Normal, __context, __compress);
    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());
            }
        }
        ::ClientMaster::list __ret;
        __is->read(__ret);
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

bool
IceDelegateM::ClientMaster::FileObjectsManager::createFolder(const ::std::string& folderName, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__connection.get(), __reference.get(), __ClientMaster__FileObjectsManager__createFolder_name, ::Ice::Normal, __context, __compress);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(folderName);
    }
    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::ClientMaster::FileObjectsManager::deleteFolder(const ::std::string& folderName, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__connection.get(), __reference.get(), __ClientMaster__FileObjectsManager__deleteFolder_name, ::Ice::Normal, __context, __compress);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(folderName);
    }
    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::ClientMaster::FileObjectsManager::deleteFile(const ::std::string& fileName, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__connection.get(), __reference.get(), __ClientMaster__FileObjectsManager__deleteFile_name, ::Ice::Normal, __context, __compress);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(fileName);
    }
    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
IceDelegateD::ClientMaster::FileObjectsManager::getFileObjectStorageInformation(const ::std::string& fileName, ::ClientMaster::FileObject& fileObj, const ::Ice::Context* __context)
{
    ::Ice::Current __current;
    __initCurrent(__current, __ClientMaster__FileObjectsManager__getFileObjectStorageInformation_name, ::Ice::Normal, __context);
    while(true)
    {
        ::IceInternal::Direct __direct(__current);
        bool __ret;
        try
        {
            ::ClientMaster::FileObjectsManager* __servant = dynamic_cast< ::ClientMaster::FileObjectsManager*>(__direct.servant().get());
            if(!__servant)
            {
                ::Ice::OperationNotExistException __opEx(__FILE__, __LINE__);
                __opEx.id = __current.id;
                __opEx.facet = __current.facet;
                __opEx.operation = __current.operation;
                throw __opEx;
            }
            try
            {
                __ret = __servant->getFileObjectStorageInformation(fileName, fileObj, __current);
            }
            catch(const ::Ice::LocalException& __ex)
            {
                throw ::IceInternal::LocalExceptionWrapper(__ex, false);
            }
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
        return __ret;
    }
}

bool
IceDelegateD::ClientMaster::FileObjectsManager::setFileObjectStorageInformation(const ::std::string& fileName, const ::ClientMaster::FileObject& fileObj, const ::Ice::Context* __context)
{
    ::Ice::Current __current;
    __initCurrent(__current, __ClientMaster__FileObjectsManager__setFileObjectStorageInformation_name, ::Ice::Normal, __context);
    while(true)
    {
        ::IceInternal::Direct __direct(__current);
        bool __ret;
        try
        {
            ::ClientMaster::FileObjectsManager* __servant = dynamic_cast< ::ClientMaster::FileObjectsManager*>(__direct.servant().get());
            if(!__servant)
            {
                ::Ice::OperationNotExistException __opEx(__FILE__, __LINE__);
                __opEx.id = __current.id;
                __opEx.facet = __current.facet;
                __opEx.operation = __current.operation;
                throw __opEx;
            }
            try
            {
                __ret = __servant->setFileObjectStorageInformation(fileName, fileObj, __current);
            }
            catch(const ::Ice::LocalException& __ex)
            {
                throw ::IceInternal::LocalExceptionWrapper(__ex, false);
            }
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
        return __ret;
    }
}

::ClientMaster::desIPList
IceDelegateD::ClientMaster::FileObjectsManager::getStorageNodes(const ::Ice::Context* __context)
{
    ::Ice::Current __current;
    __initCurrent(__current, __ClientMaster__FileObjectsManager__getStorageNodes_name, ::Ice::Normal, __context);
    while(true)
    {
        ::IceInternal::Direct __direct(__current);
        ::ClientMaster::desIPList __ret;
        try
        {
            ::ClientMaster::FileObjectsManager* __servant = dynamic_cast< ::ClientMaster::FileObjectsManager*>(__direct.servant().get());
            if(!__servant)
            {
                ::Ice::OperationNotExistException __opEx(__FILE__, __LINE__);
                __opEx.id = __current.id;
                __opEx.facet = __current.facet;
                __opEx.operation = __current.operation;
                throw __opEx;
            }
            try
            {
                __ret = __servant->getStorageNodes(__current);
            }
            catch(const ::Ice::LocalException& __ex)
            {
                throw ::IceInternal::LocalExceptionWrapper(__ex, false);
            }
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
        return __ret;
    }
}

::ClientMaster::list
IceDelegateD::ClientMaster::FileObjectsManager::getFSList(const ::Ice::Context* __context)
{
    ::Ice::Current __current;
    __initCurrent(__current, __ClientMaster__FileObjectsManager__getFSList_name, ::Ice::Normal, __context);
    while(true)
    {
        ::IceInternal::Direct __direct(__current);
        ::ClientMaster::list __ret;
        try
        {
            ::ClientMaster::FileObjectsManager* __servant = dynamic_cast< ::ClientMaster::FileObjectsManager*>(__direct.servant().get());
            if(!__servant)
            {
                ::Ice::OperationNotExistException __opEx(__FILE__, __LINE__);
                __opEx.id = __current.id;
                __opEx.facet = __current.facet;
                __opEx.operation = __current.operation;
                throw __opEx;
            }
            try
            {
                __ret = __servant->getFSList(__current);
            }
            catch(const ::Ice::LocalException& __ex)
            {
                throw ::IceInternal::LocalExceptionWrapper(__ex, false);
            }
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
        return __ret;
    }
}