clientmaster.cpp

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

bool
IceDelegateD::ClientMaster::FileObjectsManager::createFolder(const ::std::string& folderName, const ::Ice::Context* __context)
{
    ::Ice::Current __current;
    __initCurrent(__current, __ClientMaster__FileObjectsManager__createFolder_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->createFolder(folderName, __current);
            }
            catch(const ::Ice::LocalException& __ex)
            {
                throw ::IceInternal::LocalExceptionWrapper(__ex, false);
            }
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
        return __ret;
    }
}

bool
IceDelegateD::ClientMaster::FileObjectsManager::deleteFolder(const ::std::string& folderName, const ::Ice::Context* __context)
{
    ::Ice::Current __current;
    __initCurrent(__current, __ClientMaster__FileObjectsManager__deleteFolder_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->deleteFolder(folderName, __current);
            }
            catch(const ::Ice::LocalException& __ex)
            {
                throw ::IceInternal::LocalExceptionWrapper(__ex, false);
            }
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
        return __ret;
    }
}

bool
IceDelegateD::ClientMaster::FileObjectsManager::deleteFile(const ::std::string& fileName, const ::Ice::Context* __context)
{
    ::Ice::Current __current;
    __initCurrent(__current, __ClientMaster__FileObjectsManager__deleteFile_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->deleteFile(fileName, __current);
            }
            catch(const ::Ice::LocalException& __ex)
            {
                throw ::IceInternal::LocalExceptionWrapper(__ex, false);
            }
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
        return __ret;
    }
}

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

static const ::std::string __ClientMaster__FileObjectsManager_ids[2] =
{
    "::ClientMaster::FileObjectsManager",
    "::Ice::Object"
};

bool
ClientMaster::FileObjectsManager::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__ClientMaster__FileObjectsManager_ids, __ClientMaster__FileObjectsManager_ids + 2, _s);
}

::std::vector< ::std::string>
ClientMaster::FileObjectsManager::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__ClientMaster__FileObjectsManager_ids[0], &__ClientMaster__FileObjectsManager_ids[2]);
}

const ::std::string&
ClientMaster::FileObjectsManager::ice_id(const ::Ice::Current&) const
{
    return __ClientMaster__FileObjectsManager_ids[0];
}

const ::std::string&
ClientMaster::FileObjectsManager::ice_staticId()
{
    return __ClientMaster__FileObjectsManager_ids[0];
}

::IceInternal::DispatchStatus
ClientMaster::FileObjectsManager::___getFileObjectStorageInformation(::IceInternal::Incoming&__inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::std::string fileName;
    __is->read(fileName);
    ::ClientMaster::FileObject fileObj;
    bool __ret = getFileObjectStorageInformation(fileName, fileObj, __current);
    if(fileObj.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        ::ClientMaster::__write(__os, &fileObj[0], &fileObj[0] + fileObj.size(), ::ClientMaster::__U__FileObject());
    }
    __os->write(__ret);
    return ::IceInternal::DispatchOK;
}

::IceInternal::DispatchStatus
ClientMaster::FileObjectsManager::___setFileObjectStorageInformation(::IceInternal::Incoming&__inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::std::string fileName;
    ::ClientMaster::FileObject fileObj;
    __is->read(fileName);
    ::ClientMaster::__read(__is, fileObj, ::ClientMaster::__U__FileObject());
    bool __ret = setFileObjectStorageInformation(fileName, fileObj, __current);
    __os->write(__ret);
    return ::IceInternal::DispatchOK;
}

::IceInternal::DispatchStatus
ClientMaster::FileObjectsManager::___getStorageNodes(::IceInternal::Incoming&__inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __os = __inS.os();
    ::ClientMaster::desIPList __ret = getStorageNodes(__current);
    if(__ret.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        __os->write(&__ret[0], &__ret[0] + __ret.size());
    }
    return ::IceInternal::DispatchOK;
}

::IceInternal::DispatchStatus
ClientMaster::FileObjectsManager::___getFSList(::IceInternal::Incoming&__inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __os = __inS.os();
    ::ClientMaster::list __ret = getFSList(__current);
    if(__ret.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        __os->write(&__ret[0], &__ret[0] + __ret.size());
    }
    return ::IceInternal::DispatchOK;
}

::IceInternal::DispatchStatus
ClientMaster::FileObjectsManager::___createFolder(::IceInternal::Incoming&__inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::std::string folderName;
    __is->read(folderName);
    bool __ret = createFolder(folderName, __current);
    __os->write(__ret);
    return ::IceInternal::DispatchOK;
}

::IceInternal::DispatchStatus
ClientMaster::FileObjectsManager::___deleteFolder(::IceInternal::Incoming&__inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::std::string folderName;
    __is->read(folderName);
    bool __ret = deleteFolder(folderName, __current);
    __os->write(__ret);
    return ::IceInternal::DispatchOK;
}

::IceInternal::DispatchStatus
ClientMaster::FileObjectsManager::___deleteFile(::IceInternal::Incoming&__inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::std::string fileName;
    __is->read(fileName);
    bool __ret = deleteFile(fileName, __current);
    __os->write(__ret);
    return ::IceInternal::DispatchOK;
}

static ::std::string __ClientMaster__FileObjectsManager_all[] =
{
    "createFolder",
    "deleteFile",
    "deleteFolder",
    "getFSList",
    "getFileObjectStorageInformation",
    "getStorageNodes",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping",
    "setFileObjectStorageInformation"
};

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

    switch(r.first - __ClientMaster__FileObjectsManager_all)
    {
        case 0:
        {
            return ___createFolder(in, current);
        }
        case 1:
        {
            return ___deleteFile(in, current);
        }
        case 2:
        {
            return ___deleteFolder(in, current);
        }
        case 3:
        {
            return ___getFSList(in, current);
        }
        case 4:
        {
            return ___getFileObjectStorageInformation(in, current);
        }
        case 5:
        {
            return ___getStorageNodes(in, current);
        }
        case 6:
        {
            return ___ice_id(in, current);
        }
        case 7:
        {
            return ___ice_ids(in, current);
        }
        case 8:
        {
            return ___ice_isA(in, current);
        }
        case 9:
        {
            return ___ice_ping(in, current);
        }
        case 10:
        {
            return ___setFileObjectStorageInformation(in, current);
        }
    }

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

void
ClientMaster::FileObjectsManager::__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
ClientMaster::FileObjectsManager::__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
ClientMaster::FileObjectsManager::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type ClientMaster::FileObjectsManager was not generated with stream support";
    throw ex;
}

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

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

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

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

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

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

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

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