The CurlMultiPartHandler class.  
 More...
#include <zypp-curl/ng/network/curlmultiparthandler.h>
|  | 
|  | CurlMultiPartHandler (ProtocolMode mode, void *easyHandle, std::vector< Range > &ranges, CurlMultiPartDataReceiver &receiver) | 
|  | ~CurlMultiPartHandler () override | 
| void * | easyHandle () const | 
| bool | canRecover () const | 
| bool | hasMoreWork () const | 
| bool | hasError () const | 
| Code | lastError () const | 
| const std::string & | lastErrorMessage () const | 
| bool | validateRange (Range &rng) | 
| bool | prepare () | 
| bool | prepareToContinue () | 
| void | finalize () | 
| bool | verifyData () | 
| std::optional< size_t > | reportedFileSize () const | 
| std::optional< off_t > | currentRange () const | 
|  | Base () | 
| virtual | ~Base () | 
| WeakPtr | parent () const | 
| void | addChild (const Base::Ptr &child) | 
| void | removeChild (const Ptr &child) | 
| const std::unordered_set< Ptr > & | children () const | 
| std::thread::id | threadId () const | 
| template<typename T> | 
| std::vector< std::weak_ptr< T > > | findChildren () const | 
| template<typename T> | 
| std::shared_ptr< T > | shared_this () const | 
| template<typename T> | 
| std::shared_ptr< T > | shared_this () | 
| template<typename T> | 
| std::weak_ptr< T > | weak_this () const | 
| template<typename T> | 
| std::weak_ptr< T > | weak_this () | 
| template<typename SenderFunc, typename ReceiverFunc> | 
| auto | connect (SenderFunc &&sFun, typename internal::MemberFunction< ReceiverFunc >::ClassType &recv, ReceiverFunc &&rFunc) | 
| template<typename SenderFunc, typename ReceiverFunc, typename ... Tracker> | 
| std::enable_if_t< std::is_member_function_pointer_v< SenderFunc >, connection > | connectFunc (SenderFunc &&sFun, ReceiverFunc &&rFunc, const Tracker &...trackers) | 
|  | 
| void | setCode (Code c, std::string msg, bool force=false) | 
| size_t | hdrcallback (char *ptr, size_t size, size_t nmemb) | 
| size_t | wrtcallback (char *ptr, size_t size, size_t nmemb) | 
| bool | parseContentRangeHeader (const std::string_view &line, size_t &start, size_t &len, size_t &fileLen) | 
| bool | parseContentTypeMultiRangeHeader (const std::string_view &line, std::string &boundary) | 
| bool | checkIfRangeChkSumIsValid (Range &rng) | 
| void | setRangeState (Range &rng, State state) | 
|  | 
| static size_t | curl_hdrcallback (char *ptr, size_t size, size_t nmemb, void *userdata) | 
| static size_t | curl_wrtcallback (char *ptr, size_t size, size_t nmemb, void *userdata) | 
|  | 
| template<typename Obj, typename Functor> | 
| static decltype(auto) | make_base_slot (Obj *o, Functor &&f) | 
| template<typename SenderFunc, typename ReceiverFunc> | 
| static auto | connect (typename internal::MemberFunction< SenderFunc >::ClassType &s, SenderFunc &&sFun, typename internal::MemberFunction< ReceiverFunc >::ClassType &recv, ReceiverFunc &&rFunc) | 
| template<typename SenderFunc, typename ReceiverFunc, typename ... Tracker> | 
| static auto | connectFunc (typename internal::MemberFunction< SenderFunc >::ClassType &s, SenderFunc &&sFun, ReceiverFunc &&rFunc, const Tracker &...trackers) | 
|  | Base (BasePrivate &dd) | 
| std::unique_ptr< BasePrivate > | d_ptr | 
The CurlMultiPartHandler class. 
multirange support for HTTP requests (https://tools.ietf.org/html/rfc7233), if not operating on a HTTP/HTTPS URL this will batch multirange requests one by one, so maybe don't use it there 
Definition at line 69 of file curlmultiparthandler.h.
◆ CheckSumBytes
◆ Code
◆ ProtocolMode
◆ State
◆ CurlMultiPartHandler()
◆ ~CurlMultiPartHandler()
  
  | 
        
          | zyppng::CurlMultiPartHandler::~CurlMultiPartHandler | ( |  | ) |  |  | override | 
 
 
◆ easyHandle()
      
        
          | void * zyppng::CurlMultiPartHandler::easyHandle | ( |  | ) | const | 
      
 
 
◆ canRecover()
      
        
          | bool zyppng::CurlMultiPartHandler::canRecover | ( |  | ) | const | 
      
 
 
◆ hasMoreWork()
      
        
          | bool zyppng::CurlMultiPartHandler::hasMoreWork | ( |  | ) | const | 
      
 
 
◆ hasError()
      
        
          | bool zyppng::CurlMultiPartHandler::hasError | ( |  | ) | const | 
      
 
 
◆ lastError()
◆ lastErrorMessage()
      
        
          | const std::string & zyppng::CurlMultiPartHandler::lastErrorMessage | ( |  | ) | const | 
      
 
 
◆ validateRange()
      
        
          | bool zyppng::CurlMultiPartHandler::validateRange | ( | Range & | rng | ) |  | 
      
 
 
◆ prepare()
      
        
          | bool zyppng::CurlMultiPartHandler::prepare | ( |  | ) |  | 
      
 
 
◆ prepareToContinue()
      
        
          | bool zyppng::CurlMultiPartHandler::prepareToContinue | ( |  | ) |  | 
      
 
 
◆ finalize()
      
        
          | void zyppng::CurlMultiPartHandler::finalize | ( |  | ) |  | 
      
 
 
◆ verifyData()
      
        
          | bool zyppng::CurlMultiPartHandler::verifyData | ( |  | ) |  | 
      
 
 
◆ reportedFileSize()
      
        
          | std::optional< size_t > zyppng::CurlMultiPartHandler::reportedFileSize | ( |  | ) | const | 
      
 
 
◆ currentRange()
      
        
          | std::optional< off_t > zyppng::CurlMultiPartHandler::currentRange | ( |  | ) | const | 
      
 
 
◆ setCode()
  
  | 
        
          | void zyppng::CurlMultiPartHandler::setCode | ( | Code | c, |  
          |  |  | std::string | msg, |  
          |  |  | bool | force = false ) |  | private | 
 
 
◆ curl_hdrcallback()
  
  | 
        
          | size_t zyppng::CurlMultiPartHandler::curl_hdrcallback | ( | char * | ptr, |  
          |  |  | size_t | size, |  
          |  |  | size_t | nmemb, |  
          |  |  | void * | userdata ) |  | staticprivate | 
 
 
◆ curl_wrtcallback()
  
  | 
        
          | size_t zyppng::CurlMultiPartHandler::curl_wrtcallback | ( | char * | ptr, |  
          |  |  | size_t | size, |  
          |  |  | size_t | nmemb, |  
          |  |  | void * | userdata ) |  | staticprivate | 
 
 
◆ hdrcallback()
  
  | 
        
          | size_t zyppng::CurlMultiPartHandler::hdrcallback | ( | char * | ptr, |  
          |  |  | size_t | size, |  
          |  |  | size_t | nmemb ) |  | private | 
 
 
◆ wrtcallback()
  
  | 
        
          | size_t zyppng::CurlMultiPartHandler::wrtcallback | ( | char * | ptr, |  
          |  |  | size_t | size, |  
          |  |  | size_t | nmemb ) |  | private | 
 
 
◆ parseContentRangeHeader()
  
  | 
        
          | bool zyppng::CurlMultiPartHandler::parseContentRangeHeader | ( | const std::string_view & | line, |  
          |  |  | size_t & | start, |  
          |  |  | size_t & | len, |  
          |  |  | size_t & | fileLen ) |  | private | 
 
 
◆ parseContentTypeMultiRangeHeader()
  
  | 
        
          | bool zyppng::CurlMultiPartHandler::parseContentTypeMultiRangeHeader | ( | const std::string_view & | line, |  
          |  |  | std::string & | boundary ) |  | private | 
 
 
◆ checkIfRangeChkSumIsValid()
  
  | 
        
          | bool zyppng::CurlMultiPartHandler::checkIfRangeChkSumIsValid | ( | Range & | rng | ) |  |  | private | 
 
 
◆ setRangeState()
  
  | 
        
          | void zyppng::CurlMultiPartHandler::setRangeState | ( | Range & | rng, |  
          |  |  | State | state ) |  | private | 
 
 
◆ _rangeAttempt
  
  | 
        
          | unsigned zyppng::CurlMultiPartHandler::_rangeAttempt[] |  | staticconstexpr | 
 
 
◆ _rangeAttemptSize
  
  | 
        
          | unsigned zyppng::CurlMultiPartHandler::_rangeAttemptSize = ( sizeof( _rangeAttempt ) / sizeof(unsigned) ) |  | staticconstexpr | 
 
 
◆ _protocolMode
◆ _easyHandle
  
  | 
        
          | void* zyppng::CurlMultiPartHandler::_easyHandle = nullptr |  | private | 
 
 
◆ _receiver
◆ _lastCode
  
  | 
        
          | Code zyppng::CurlMultiPartHandler::_lastCode = Code::NoError |  | private | 
 
 
◆ _lastErrorMsg
  
  | 
        
          | std::string zyppng::CurlMultiPartHandler::_lastErrorMsg |  | private | 
 
 
◆ _allHeadersReceived
  
  | 
        
          | bool zyppng::CurlMultiPartHandler::_allHeadersReceived = false |  | private | 
 
 
◆ _gotContentRangeInfo
  
  | 
        
          | bool zyppng::CurlMultiPartHandler::_gotContentRangeInfo = false |  | private | 
 
 
◆ _isMuliPartResponse
  
  | 
        
          | bool zyppng::CurlMultiPartHandler::_isMuliPartResponse = false |  | private | 
 
 
◆ _seperatorString
  
  | 
        
          | std::string zyppng::CurlMultiPartHandler::_seperatorString |  | private | 
 
The seperator string for multipart responses as defined in RFC 7233 Section 4.1. 
Definition at line 174 of file curlmultiparthandler.h.
 
 
◆ _rangePrefaceBuffer
  
  | 
        
          | std::vector<char> zyppng::CurlMultiPartHandler::_rangePrefaceBuffer |  | private | 
 
 
◆ _currentRange
  
  | 
        
          | std::optional<off_t> zyppng::CurlMultiPartHandler::_currentRange |  | private | 
 
 
◆ _currentSrvRange
  
  | 
        
          | std::optional<Range> zyppng::CurlMultiPartHandler::_currentSrvRange |  | private | 
 
 
◆ _reportedFileSize
  
  | 
        
          | std::optional<size_t> zyppng::CurlMultiPartHandler::_reportedFileSize |  | private | 
 
 
◆ _rangeAttemptIdx
  
  | 
        
          | unsigned zyppng::CurlMultiPartHandler::_rangeAttemptIdx = 0 |  | private | 
 
 
◆ _requestedRanges
  
  | 
        
          | std::vector<Range>& zyppng::CurlMultiPartHandler::_requestedRanges |  | private | 
 
 
The documentation for this class was generated from the following files: