EIC code displayed by LXR master/​include/​xrootd/​XrdCl/​XrdClXRootDResponses.hh	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-06-24 08:38:07

 //------------------------------------------------------------------------------
 // Copyright (c) 2011-2012 by European Organization for Nuclear Research (CERN)
 // Author: Lukasz Janyst <ljanyst@cern.ch>
 //------------------------------------------------------------------------------
 // XRootD is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Lesser General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 //
 // XRootD is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public License
 // along with XRootD.  If not, see <http://www.gnu.org/licenses/>.
 //------------------------------------------------------------------------------
 
 #ifndef __XRD_CL_XROOTD_RESPONSES_HH__
 #define __XRD_CL_XROOTD_RESPONSES_HH__
 
 #include "XrdCl/XrdClBuffer.hh"
 #include "XrdCl/XrdClStatus.hh"
 #include "XrdCl/XrdClURL.hh"
 #include "XrdCl/XrdClAnyObject.hh"
 #include "XProtocol/XProtocol.hh"
 
 #include <string>
 #include <vector>
 #include <list>
 #include <ctime>
 #include <tuple>
 #include <memory>
 #include <functional>
 
 #include <sys/uio.h>
 
 namespace XrdCl
 {
   //----------------------------------------------------------------------------
   //! Path location info
   //----------------------------------------------------------------------------
   class LocationInfo
   {
     public:
       //------------------------------------------------------------------------
       //! Describes the node type and file status for a given location
       //------------------------------------------------------------------------
       enum LocationType
       {
         ManagerOnline,   //!< manager node where the file is online
         ManagerPending,  //!< manager node where the file is pending to be online
         ServerOnline,    //!< server node where the file is online
         ServerPending    //!< server node where the file is pending to be online
       };
 
       //------------------------------------------------------------------------
       //! Describes the allowed access type for the file at given location
       //------------------------------------------------------------------------
       enum AccessType
       {
         Read,            //!< read access is allowed
         ReadWrite        //!< write access is allowed
       };
 
       //------------------------------------------------------------------------
       //! Location
       //------------------------------------------------------------------------
       class Location
       {
         public:
 
           //--------------------------------------------------------------------
           //! Constructor
           //--------------------------------------------------------------------
           Location( const std::string  &address,
                     LocationType        type,
                     AccessType          access ):
             pAddress( address ),
             pType( type ),
             pAccess( access ) {}
 
           //--------------------------------------------------------------------
           //! Get address
           //--------------------------------------------------------------------
           const std::string &GetAddress() const
           {
             return pAddress;
           }
 
           //--------------------------------------------------------------------
           //! Get location type
           //--------------------------------------------------------------------
           LocationType GetType() const
           {
             return pType;
           }
 
           //--------------------------------------------------------------------
           //! Get access type
           //--------------------------------------------------------------------
           AccessType GetAccessType() const
           {
             return pAccess;
           }
 
           //--------------------------------------------------------------------
           //! Check whether the location is a server
           //--------------------------------------------------------------------
           bool IsServer() const
           {
             return pType == ServerOnline || pType == ServerPending;
           }
 
           //--------------------------------------------------------------------
           //! Check whether the location is a manager
           //--------------------------------------------------------------------
           bool IsManager() const
           {
             return pType == ManagerOnline || pType == ManagerPending;
           }
 
         private:
           std::string  pAddress;
           LocationType pType;
           AccessType   pAccess;
       };
 
       //------------------------------------------------------------------------
       //! List of locations
       //------------------------------------------------------------------------
       typedef std::vector<Location>        LocationList;
 
       //------------------------------------------------------------------------
       //! Iterator over locations
       //------------------------------------------------------------------------
       typedef LocationList::iterator       Iterator;
 
       //------------------------------------------------------------------------
       //! Iterator over locations
       //------------------------------------------------------------------------
       typedef LocationList::const_iterator ConstIterator;
 
       //------------------------------------------------------------------------
       //! Constructor
       //------------------------------------------------------------------------
       LocationInfo();
 
       //------------------------------------------------------------------------
       //! Get number of locations
       //------------------------------------------------------------------------
       uint32_t GetSize() const
       {
         return pLocations.size();
       }
 
       //------------------------------------------------------------------------
       //! Get the location at index
       //------------------------------------------------------------------------
       Location &At( uint32_t index )
       {
         return pLocations[index];
       }
 
       //------------------------------------------------------------------------
       //! Get the location begin iterator
       //------------------------------------------------------------------------
       Iterator Begin()
       {
         return pLocations.begin();
       }
 
       //------------------------------------------------------------------------
       //! Get the location begin iterator
       //------------------------------------------------------------------------
       ConstIterator Begin() const
       {
         return pLocations.begin();
       }
 
       //------------------------------------------------------------------------
       //! Get the location end iterator
       //------------------------------------------------------------------------
       Iterator End()
       {
         return pLocations.end();
       }
 
       //------------------------------------------------------------------------
       //! Get the location end iterator
       //------------------------------------------------------------------------
       ConstIterator End() const
       {
         return pLocations.end();
       }
 
       //------------------------------------------------------------------------
       //! Add a location
       //------------------------------------------------------------------------
       void Add( const Location &location )
       {
         pLocations.push_back( location );
       }
 
       //------------------------------------------------------------------------
       //! Parse server response and fill up the object
       //------------------------------------------------------------------------
       bool ParseServerResponse( const char *data );
 
     private:
       bool ProcessLocation( std::string &location );
       LocationList pLocations;
   };
 
   //----------------------------------------------------------------------------
   //! Request status
   //----------------------------------------------------------------------------
   class XRootDStatus: public Status
   {
     public:
       //------------------------------------------------------------------------
       //! Constructor
       //------------------------------------------------------------------------
       XRootDStatus( uint16_t           st      = 0,
                     uint16_t           code    = 0,
                     uint32_t           errN    = 0,
                     const std::string &message = "" ):
         Status( st, code, errN ),
         pMessage( message ) {}
 
       //------------------------------------------------------------------------
       //! Constructor
       //------------------------------------------------------------------------
       XRootDStatus( const Status      &st,
                     const std::string &message = "" ):
         Status( st ),
         pMessage( message ) {}
 
       //------------------------------------------------------------------------
       //! Get error message
       //------------------------------------------------------------------------
       const std::string &GetErrorMessage() const
       {
         return pMessage;
       }
 
       //------------------------------------------------------------------------
       //! Set the error message
       //------------------------------------------------------------------------
       void SetErrorMessage( const std::string &message )
       {
         pMessage = message;
       }
 
       //------------------------------------------------------------------------
       //! Convert to string
       //------------------------------------------------------------------------
       std::string ToStr() const
       {
         if( code == errErrorResponse )
         {
           std::ostringstream o;
           o << "[ERROR] Server responded with an error: [" << errNo << "] ";
           o << pMessage << std::endl;
           return o.str();
         }
         std::string str = ToString();
         if( !pMessage.empty() )
           str += ": " + pMessage;
         return str;
       }
 
     private:
       std::string pMessage;
   };
 
   //----------------------------------------------------------------------------
   //! Tuple indexes of name and value fields in xattr_t
   //----------------------------------------------------------------------------
   enum
   {
     xattr_name  = 0,
     xattr_value = 1
   };
 
   //----------------------------------------------------------------------------
   //! Extended attribute key - value pair
   //----------------------------------------------------------------------------
   typedef std::tuple<std::string, std::string> xattr_t;
 
   //----------------------------------------------------------------------------
   //! Extended attribute operation status
   //----------------------------------------------------------------------------
   struct XAttrStatus
   {
       friend class FileStateHandler;
       friend class FileSystem;
 
       XAttrStatus( const std::string &name, const XRootDStatus &status ) :
         name( name ), status( status )
       {
 
       }
 
       std::string name;
       XRootDStatus status;
   };
 
   //----------------------------------------------------------------------------
   //! Extended attributes with status
   //----------------------------------------------------------------------------
   struct XAttr : public XAttrStatus
   {
       friend class FileStateHandler;
       friend class FileSystem;
 
       XAttr( const std::string  &name, const XRootDStatus &status ) :
         XAttrStatus( name, status )
       {
 
       }
 
       XAttr( const std::string  &name, const std::string &value = "",
              const XRootDStatus &status = XRootDStatus() ) :
         XAttrStatus( name, status ), value( value )
       {
 
       }
 
       std::string value;
   };
 
   //----------------------------------------------------------------------------
   //! Binary buffer
   //----------------------------------------------------------------------------
   typedef Buffer BinaryDataInfo;
 
   //----------------------------------------------------------------------------
   //! Protocol response
   //----------------------------------------------------------------------------
   class ProtocolInfo
   {
     public:
       //------------------------------------------------------------------------
       //! Types of XRootD servers
       //------------------------------------------------------------------------
       enum HostTypes
       {
         IsManager = kXR_isManager,   //!< Manager
         IsServer  = kXR_isServer,    //!< Data server
         AttrCache = kXR_attrCache,   //!< Cache attribute
         AttrMeta  = kXR_attrMeta,    //!< Meta attribute
         AttrProxy = kXR_attrProxy,   //!< Proxy attribute
         AttrSuper = kXR_attrSuper    //!< Supervisor attribute
       };
 
       //------------------------------------------------------------------------
       //! Constructor
       //------------------------------------------------------------------------
       ProtocolInfo( uint32_t version, uint32_t hostInfo ):
         pVersion( version ), pHostInfo( hostInfo ) {}
 
       //------------------------------------------------------------------------
       //! Get version info
       //------------------------------------------------------------------------
       uint32_t GetVersion() const
       {
         return pVersion;
       }
 
       //------------------------------------------------------------------------
       //! Get host info
       //------------------------------------------------------------------------
       uint32_t GetHostInfo() const
       {
         return pHostInfo;
       }
 
       //------------------------------------------------------------------------
       //! Test host info flags
       //------------------------------------------------------------------------
       bool TestHostInfo( uint32_t flags )
       {
         return pHostInfo & flags;
       }
 
     private:
       uint32_t pVersion;
       uint32_t pHostInfo;
   };
 
   //----------------------------------------------------------------------------
   //! Object stat info implementation forward declaration
   //----------------------------------------------------------------------------
   struct StatInfoImpl;
 
   //----------------------------------------------------------------------------
   //! Object stat info
   //----------------------------------------------------------------------------
   class StatInfo
   {
     public:
       //------------------------------------------------------------------------
       //! Flags
       //------------------------------------------------------------------------
       enum Flags
       {
         XBitSet      = kXR_xset,      //!< Executable/searchable bit set
         IsDir        = kXR_isDir,     //!< This is a directory
         Other        = kXR_other,     //!< Neither a file nor a directory
         Offline      = kXR_offline,   //!< File is not online (ie. on disk)
         POSCPending  = kXR_poscpend,  //!< File opened with POST flag, not yet
                                       //!< successfully closed
         IsReadable   = kXR_readable,  //!< Read access is allowed
         IsWritable   = kXR_writable,  //!< Write access is allowed
         BackUpExists = kXR_bkpexist   //!< Back up copy exists
       };
 
       //------------------------------------------------------------------------
       //! Constructor
       //------------------------------------------------------------------------
       StatInfo();
 
       //------------------------------------------------------------------------
       //! Constructor
       //------------------------------------------------------------------------
       StatInfo( const std::string &id, uint64_t size, uint32_t flags,
                 uint64_t modTime );
 
       //------------------------------------------------------------------------
       //! Copy constructor
       //------------------------------------------------------------------------
       StatInfo( const StatInfo &info );
 
       //------------------------------------------------------------------------
       //! Destructor
       //------------------------------------------------------------------------
       ~StatInfo();
 
       //------------------------------------------------------------------------
       //! Get id
       //------------------------------------------------------------------------
       const std::string& GetId() const;
 
       //------------------------------------------------------------------------
       //! Get size (in bytes)
       //------------------------------------------------------------------------
       uint64_t GetSize() const;
 
       //------------------------------------------------------------------------
       //! Set size
       //------------------------------------------------------------------------
       void SetSize( uint64_t size );
 
       //------------------------------------------------------------------------
       //! Get flags
       //------------------------------------------------------------------------
       uint32_t GetFlags() const;
 
       //------------------------------------------------------------------------
       //! Set flags
       //------------------------------------------------------------------------
       void SetFlags( uint32_t flags );
 
       //------------------------------------------------------------------------
       //! Test flags
       //------------------------------------------------------------------------
       bool TestFlags( uint32_t flags ) const;
 
       //------------------------------------------------------------------------
       //! Get modification time (in seconds since epoch)
       //------------------------------------------------------------------------
       uint64_t GetModTime() const;
 
       //------------------------------------------------------------------------
       //! Get modification time
       //------------------------------------------------------------------------
       std::string GetModTimeAsString() const;
 
       //------------------------------------------------------------------------
       //! Get change time (in seconds since epoch)
       //------------------------------------------------------------------------
       uint64_t GetChangeTime() const;
 
       //------------------------------------------------------------------------
       //! Get change time
       //------------------------------------------------------------------------
       std::string GetChangeTimeAsString() const;
 
       //------------------------------------------------------------------------
       //! Get change time (in seconds since epoch)
       //------------------------------------------------------------------------
       uint64_t GetAccessTime() const;
 
       //------------------------------------------------------------------------
       //! Get change time
       //------------------------------------------------------------------------
       std::string GetAccessTimeAsString() const;
 
       //------------------------------------------------------------------------
       //! Get mode
       //------------------------------------------------------------------------
       const std::string& GetModeAsString() const;
 
       //------------------------------------------------------------------------
       //! Get mode
       //------------------------------------------------------------------------
       const std::string GetModeAsOctString() const;
 
       //------------------------------------------------------------------------
       //! Get owner
       //------------------------------------------------------------------------
       const std::string& GetOwner() const;
 
       //------------------------------------------------------------------------
       //! Get group
       //------------------------------------------------------------------------
       const std::string& GetGroup() const;
 
       //------------------------------------------------------------------------
       //! Get checksum
       //------------------------------------------------------------------------
       const std::string& GetChecksum() const;
 
       //------------------------------------------------------------------------
       //! Parse server response and fill up the object
       //------------------------------------------------------------------------
       bool ParseServerResponse( const char *data );
 
       //------------------------------------------------------------------------
       //! Has extended stat information
       //------------------------------------------------------------------------
       bool ExtendedFormat() const;
 
       //------------------------------------------------------------------------
       //! Has checksum
       //------------------------------------------------------------------------
       bool HasChecksum() const;
 
     private:
 
       static inline std::string TimeToString( uint64_t time )
       {
         char ts[256];
         time_t modTime = time;
         tm *t = gmtime( &modTime );
         strftime( ts, 255, "%F %T", t );
         return ts;
       }
 
       static inline void OctToString( uint8_t oct, std::string &str )
       {
         static const uint8_t r_mask = 0x4;
         static const uint8_t w_mask = 0x2;
         static const uint8_t x_mask = 0x1;
 
         if( r_mask & oct ) str.push_back( 'r' );
         else str.push_back( '-' );
 
         if( w_mask & oct ) str.push_back( 'w' );
         else str.push_back( '-' );
 
         if( x_mask & oct ) str.push_back( 'x' );
         else str.push_back( '-' );
       }
 
       std::unique_ptr<StatInfoImpl> pImpl;
   };
 
   //----------------------------------------------------------------------------
   //! VFS stat info
   //----------------------------------------------------------------------------
   class StatInfoVFS
   {
     public:
       //------------------------------------------------------------------------
       //! Constructor
       //------------------------------------------------------------------------
       StatInfoVFS();
 
       //------------------------------------------------------------------------
       //! Get number of nodes that can provide read/write space
       //------------------------------------------------------------------------
       uint64_t GetNodesRW() const
       {
         return pNodesRW;
       }
 
       //------------------------------------------------------------------------
       //! Get size of the largest contiguous area of free r/w space (in MB)
       //------------------------------------------------------------------------
       uint64_t GetFreeRW() const
       {
         return pFreeRW;
       }
 
       //------------------------------------------------------------------------
       //! Get percentage of the partition utilization represented by FreeRW
       //------------------------------------------------------------------------
       uint8_t GetUtilizationRW() const
       {
         return pUtilizationRW;
       }
 
       //------------------------------------------------------------------------
       //! Get number of nodes that can provide staging space
       //------------------------------------------------------------------------
       uint64_t GetNodesStaging() const
       {
         return pNodesStaging;
       }
 
       //------------------------------------------------------------------------
       //! Get size of the largest contiguous area of free staging space (in MB)
       //------------------------------------------------------------------------
       uint64_t GetFreeStaging() const
       {
         return pFreeStaging;
       }
 
       //------------------------------------------------------------------------
       //! Get percentage of the partition utilization represented by FreeStaging
       //------------------------------------------------------------------------
       uint8_t GetUtilizationStaging() const
       {
         return pUtilizationStaging;
       }
 
       //------------------------------------------------------------------------
       //! Parse server response and fill up the object
       //------------------------------------------------------------------------
       bool ParseServerResponse( const char *data );
 
     private:
 
       //------------------------------------------------------------------------
       // kXR_vfs stat
       //------------------------------------------------------------------------
       uint64_t    pNodesRW;
       uint64_t    pFreeRW;
       uint32_t    pUtilizationRW;
       uint64_t    pNodesStaging;
       uint64_t    pFreeStaging;
       uint32_t    pUtilizationStaging;
   };
 
   //----------------------------------------------------------------------------
   //! Directory list
   //----------------------------------------------------------------------------
   class DirectoryList
   {
     public:
 
       //------------------------------------------------------------------------
       //! Directory entry
       //------------------------------------------------------------------------
       class ListEntry
       {
         public:
           //--------------------------------------------------------------------
           //! Constructor
           //--------------------------------------------------------------------
           ListEntry( const std::string &hostAddress,
                      const std::string &name,
                      StatInfo          *statInfo = 0):
             pHostAddress( hostAddress ),
             pName( SanitizeName( name ) ),
             pStatInfo( statInfo )
           {}
 
           //--------------------------------------------------------------------
           //! Destructor
           //--------------------------------------------------------------------
           ~ListEntry()
           {
             delete pStatInfo;
           }
 
           //--------------------------------------------------------------------
           //! Get host address
           //--------------------------------------------------------------------
           const std::string &GetHostAddress() const
           {
             return pHostAddress;
           }
 
           //--------------------------------------------------------------------
           //! Get file name
           //--------------------------------------------------------------------
           const std::string &GetName() const
           {
             return pName;
           }
 
           //--------------------------------------------------------------------
           //! Get the stat info object
           //--------------------------------------------------------------------
           StatInfo *GetStatInfo()
           {
             return pStatInfo;
           }
 
           //--------------------------------------------------------------------
           //! Get the stat info object
           //--------------------------------------------------------------------
           const StatInfo *GetStatInfo() const
           {
             return pStatInfo;
           }
 
           //--------------------------------------------------------------------
           //! Set the stat info object (and transfer the ownership)
           //--------------------------------------------------------------------
           void SetStatInfo( StatInfo *info )
           {
             pStatInfo = info;
           }
 
         private:
 
           inline static std::string SanitizeName( const std::string &name )
           {
             const char *cstr = name.c_str();
             while( *cstr == '/' ) // the C string is guaranteed to end with '\0'
               ++cstr;
             return cstr;
           }
 
           std::string  pHostAddress;
           std::string  pName;
           StatInfo    *pStatInfo;
       };
 
       //------------------------------------------------------------------------
       //! Constructor
       //------------------------------------------------------------------------
       DirectoryList();
 
       //------------------------------------------------------------------------
       //! Destructor
       //------------------------------------------------------------------------
       ~DirectoryList();
 
       //------------------------------------------------------------------------
       //! Directory listing
       //------------------------------------------------------------------------
       typedef std::vector<ListEntry*>  DirList;
 
       //------------------------------------------------------------------------
       //! Directory listing iterator
       //------------------------------------------------------------------------
       typedef DirList::iterator       Iterator;
 
       //------------------------------------------------------------------------
       //! Directory listing const iterator
       //------------------------------------------------------------------------
       typedef DirList::const_iterator ConstIterator;
 
       //------------------------------------------------------------------------
       //! Add an entry to the list - takes ownership
       //------------------------------------------------------------------------
       void Add( ListEntry *entry )
       {
         pDirList.push_back( entry );
       }
 
       //------------------------------------------------------------------------
       //! Get an entry at given index
       //------------------------------------------------------------------------
       ListEntry *At( uint32_t index )
       {
         return pDirList[index];
       }
 
       //------------------------------------------------------------------------
       //! Get the begin iterator
       //------------------------------------------------------------------------
       Iterator Begin()
       {
         return pDirList.begin();
       }
 
       //------------------------------------------------------------------------
       //! Get the begin iterator
       //------------------------------------------------------------------------
       ConstIterator Begin() const
       {
         return pDirList.begin();
       }
 
       //------------------------------------------------------------------------
       //! Get the end iterator
       //------------------------------------------------------------------------
       Iterator End()
       {
         return pDirList.end();
       }
 
       //------------------------------------------------------------------------
       //! Get the end iterator
       //------------------------------------------------------------------------
       ConstIterator End() const
       {
         return pDirList.end();
       }
 
       //------------------------------------------------------------------------
       //! Get the size of the listing
       //------------------------------------------------------------------------
       uint32_t GetSize() const
       {
         return pDirList.size();
       }
 
       //------------------------------------------------------------------------
       //! Get parent directory name
       //------------------------------------------------------------------------
       const std::string &GetParentName() const
       {
         return pParent;
       }
 
       //------------------------------------------------------------------------
       //! Set name of the parent directory
       //------------------------------------------------------------------------
       void SetParentName( const std::string &parent )
       {
         size_t pos = parent.find( '?' );
         pParent = pos == std::string::npos ? parent : parent.substr( 0, pos );
         if( !pParent.empty() && pParent[pParent.length()-1] != '/' )
           pParent += "/";
       }
 
       //------------------------------------------------------------------------
       //! Parse server response and fill up the object
       //------------------------------------------------------------------------
       bool ParseServerResponse( const std::string &hostId,
                                 const char *data );
 
       //------------------------------------------------------------------------
       //! Parse chunked server response and fill up the object
       //------------------------------------------------------------------------
       bool ParseServerResponse( const std::string &hostId,
                                 const char *data,
                                 bool isDStat );
 
       //------------------------------------------------------------------------
       //! Returns true if data contain stat info
       //------------------------------------------------------------------------
       static bool HasStatInfo( const char *data );
 
     private:
       DirList     pDirList;
       std::string pParent;
 
       static const std::string dStatPrefix;
   };
 
   //----------------------------------------------------------------------------
   //! Information returned by file open operation
   //----------------------------------------------------------------------------
   class OpenInfo
   {
     public:
       //------------------------------------------------------------------------
       //! Constructor
       //------------------------------------------------------------------------
       OpenInfo( const uint8_t *fileHandle,
                 uint64_t       sessionId,
                 StatInfo *statInfo        = 0 ):
         pSessionId(sessionId), pStatInfo( statInfo )
       {
         memcpy( pFileHandle, fileHandle, 4 );
       }
 
       //------------------------------------------------------------------------
       //! Destructor
       //------------------------------------------------------------------------
       ~OpenInfo()
       {
         delete pStatInfo;
       }
 
       //------------------------------------------------------------------------
       //! Get the file handle (4bytes)
       //------------------------------------------------------------------------
       void GetFileHandle( uint8_t *fileHandle ) const
       {
         memcpy( fileHandle, pFileHandle, 4 );
       }
 
       //------------------------------------------------------------------------
       //! Get the stat info
       //------------------------------------------------------------------------
       const StatInfo *GetStatInfo() const
       {
         return pStatInfo;
       }
 
       //------------------------------------------------------------------------
       // Get session ID
       //------------------------------------------------------------------------
       uint64_t GetSessionId() const
       {
         return pSessionId;
       }
 
     private:
       uint8_t   pFileHandle[4];
       uint64_t  pSessionId;
       StatInfo *pStatInfo;
   };
 
   //----------------------------------------------------------------------------
   //! Describe a data chunk for vector read
   //----------------------------------------------------------------------------
   struct ChunkInfo
   {
     //--------------------------------------------------------------------------
     //! Constructor
     //--------------------------------------------------------------------------
     ChunkInfo( uint64_t off = 0, uint32_t len = 0, void *buff = 0 ):
       offset( off ), length( len ), buffer(buff) {}
 
     //----------------------------------------------------------------------------
     //! Get the offset
     //----------------------------------------------------------------------------
     inline uint64_t GetOffset() const
     {
       return offset;
     }
 
     //----------------------------------------------------------------------------
     //! Get the data length
     //----------------------------------------------------------------------------
     inline uint32_t GetLength() const
     {
       return length;
     }
 
     //----------------------------------------------------------------------------
     //! Get the buffer
     //----------------------------------------------------------------------------
     inline void* GetBuffer()
     {
       return buffer;
     }
 
     uint64_t  offset; //! offset in the file
     uint32_t  length; //! length of the chunk
     void     *buffer; //! optional buffer pointer
   };
 
   struct PageInfoImpl;
 
   struct PageInfo
   {
     //----------------------------------------------------------------------------
     //! Default constructor
     //----------------------------------------------------------------------------
     PageInfo( uint64_t offset = 0, uint32_t length = 0, void *buffer = 0,
               std::vector<uint32_t> &&cksums = std::vector<uint32_t>() );
 
     //----------------------------------------------------------------------------
     //! Move constructor
     //----------------------------------------------------------------------------
     PageInfo( PageInfo &&pginf );
 
     //----------------------------------------------------------------------------
     //! Move assigment operator
     //----------------------------------------------------------------------------
     PageInfo& operator=( PageInfo &&pginf );
 
     //----------------------------------------------------------------------------
     //! Destructor
     //----------------------------------------------------------------------------
     ~PageInfo();
 
     //----------------------------------------------------------------------------
     //! Get the offset
     //----------------------------------------------------------------------------
     uint64_t GetOffset() const;
 
     //----------------------------------------------------------------------------
     //! Get the data length
     //----------------------------------------------------------------------------
     uint32_t GetLength() const;
 
     //----------------------------------------------------------------------------
     //! Get the buffer
     //----------------------------------------------------------------------------
     void* GetBuffer();
 
     //----------------------------------------------------------------------------
     //! Get the checksums
     //----------------------------------------------------------------------------
     std::vector<uint32_t>& GetCksums();
 
     //----------------------------------------------------------------------------
     //! Get number of repaired pages
     //----------------------------------------------------------------------------
     size_t GetNbRepair();
 
     //----------------------------------------------------------------------------
     //! Set number of repaired pages
     //----------------------------------------------------------------------------
     void SetNbRepair( size_t nbrepair );
 
     private:
       //--------------------------------------------------------------------------
       //! pointer to implementation
       //--------------------------------------------------------------------------
       std::unique_ptr<PageInfoImpl> pImpl;
   };
 
   struct RetryInfoImpl;
 
   struct RetryInfo
   {
     //----------------------------------------------------------------------------
     //! Constructor
     //----------------------------------------------------------------------------
     RetryInfo( std::vector<std::tuple<uint64_t, uint32_t>> && retries );
 
     //----------------------------------------------------------------------------
     //! Destructor
     //----------------------------------------------------------------------------
     ~RetryInfo();
 
     //----------------------------------------------------------------------------
     //! @return : true if some pages need retrying, false otherwise
     //----------------------------------------------------------------------------
     bool NeedRetry();
 
     //----------------------------------------------------------------------------
     //! @return number of pages that need to be retransmitted
     //----------------------------------------------------------------------------
     size_t Size();
 
     //----------------------------------------------------------------------------
     //! @return : offset and size of respective page that requires to be
     //            retransmitted
     //----------------------------------------------------------------------------
     std::tuple<uint64_t, uint32_t> At( size_t i );
 
     private:
       //--------------------------------------------------------------------------
       //! pointer to implementation
       //--------------------------------------------------------------------------
       std::unique_ptr<RetryInfoImpl> pImpl;
   };
 
   //----------------------------------------------------------------------------
   //! List of chunks
   //----------------------------------------------------------------------------
   typedef std::vector<ChunkInfo> ChunkList;
 
   //----------------------------------------------------------------------------
   //! Vector read info
   //----------------------------------------------------------------------------
   class VectorReadInfo
   {
     public:
       //------------------------------------------------------------------------
       //! Constructor
       //------------------------------------------------------------------------
       VectorReadInfo(): pSize( 0 ) {}
 
       //------------------------------------------------------------------------
       //! Get Size
       //------------------------------------------------------------------------
       uint32_t GetSize() const
       {
         return pSize;
       }
 
       //------------------------------------------------------------------------
       //! Set size
       //------------------------------------------------------------------------
       void SetSize( uint32_t size )
       {
         pSize = size;
       }
 
       //------------------------------------------------------------------------
       //! Get chunks
       //------------------------------------------------------------------------
       ChunkList &GetChunks()
       {
         return pChunks;
       }
 
       //------------------------------------------------------------------------
       //! Get chunks
       //------------------------------------------------------------------------
       const ChunkList &GetChunks() const
       {
         return pChunks;
       }
 
     private:
       ChunkList pChunks;
       uint32_t  pSize;
   };
 
   //----------------------------------------------------------------------------
   // List of URLs
   //----------------------------------------------------------------------------
   struct HostInfo
   {
     HostInfo():
       flags(0), protocol(0), loadBalancer(false) {}
     HostInfo( const URL &u, bool lb = false ):
       flags(0), protocol(0), loadBalancer(lb), url(u) {}
     uint32_t flags;        //!< Host type
     uint32_t protocol;     //!< Version of the protocol the host is speaking
     bool     loadBalancer; //!< Was the host used as a load balancer
     URL      url;          //!< URL of the host
   };
 
   typedef std::vector<HostInfo> HostList;
 
   //----------------------------------------------------------------------------
   //! Handle an async response
   //----------------------------------------------------------------------------
   class ResponseHandler
   {
     public:
       virtual ~ResponseHandler() {}
 
       //------------------------------------------------------------------------
       //! Called when a response to associated request arrives or an error
       //! occurs
       //!
       //! @param status   status of the request
       //! @param response an object associated with the response
       //!                 (request dependent)
       //! @param hostList list of hosts the request was redirected to
       //------------------------------------------------------------------------
       virtual void HandleResponseWithHosts( XRootDStatus *status,
                                             AnyObject    *response,
                                             HostList     *hostList )
       {
         delete hostList;
         HandleResponse( status, response );
       }
 
       //------------------------------------------------------------------------
       //! Called when a response to associated request arrives or an error
       //! occurs
       //!
       //! @param status   status of the request
       //! @param response an object associated with the response
       //!                 (request dependent)
       //------------------------------------------------------------------------
       virtual void HandleResponse( XRootDStatus *status,
                                    AnyObject    *response )
       {
         (void)status; (void)response;
       }
 
       //------------------------------------------------------------------------
       //! Factory function for generating handler objects from lambdas
       //!
       //! @param func : the callback, must not throw
       //! @return     : ResponseHandler wrapper with the user callback
       //------------------------------------------------------------------------
       static ResponseHandler* Wrap( std::function<void(XRootDStatus&, AnyObject&)> func );
 
       //------------------------------------------------------------------------
       //! Factory function for generating handler objects from lambdas
       //!
       //! @param func : the callback, must not throw
       //! @return     : ResponseHandler wrapper with the user callback
       //------------------------------------------------------------------------
       static ResponseHandler* Wrap( std::function<void(XRootDStatus*, AnyObject*)> func );
   };
 }
 
 #endif // __XRD_CL_XROOTD_RESPONSES_HH__

This page was automatically generated by the 2.3.7 LXR engine. The LXR team