libcurl-ന്റെ ബൈനറി പ്രതികരണങ്ങൾ C++ std::string-ലേക്ക് സ്വീകരിക്കുക

ഒരു പ്രോക്സിക്ക് HTML വിജയകരമായി ലഭിച്ചാലും ഒരു ചിത്രം C++ ബഫറിലേക്ക് പകർത്തുമ്പോൾ അത് കേടുവരുത്താം. പ്രോക്സി പ്രോട്ടോക്കോൾ മാറ്റുന്നതിന് മുമ്പ്, സ്വീകരണ callback-ഉം അതിന്റെ context ആയി നൽകുന്ന വസ്തുവും പരിശോധിക്കുക.

CURLOPT_WRITEDATA എഴുത്ത് callback-ലേക്ക് ഒരു പോയിന്റർ നൽകുന്നു. ഇഷ്ടാനുസൃത callback ഇല്ലാതെ, libcurl-ന്റെ സ്വതവേയുള്ള എഴുത്തുകാരൻ FILE * പ്രതീക്ഷിക്കുന്നു. &response പോലുള്ള വിലാസം, response ഒരു std::string ആകുമ്പോൾ, നിങ്ങളുടെ callback ആ context ഉദ്ദേശിച്ച തരത്തിലേക്ക് തിരികെ മാറ്റുമ്പോൾ മാത്രമേ അർത്ഥവത്താകൂ.

static size_t receive(char* data, size_t size,
                      size_t count, void* context) {
    const size_t bytes = size * count;
    auto* body = static_cast<std::string*>(context);
    try {
        body->append(data, bytes);
    } catch (...) {
        return 0;
    }
    return bytes;
}

രണ്ടു പകുതികളും കൈമാറ്റത്തിന് ഉപയോഗിക്കുന്ന ലളിതമായ ഹാൻഡിലിൽ രജിസ്റ്റർ ചെയ്യുക:

std::string response;
curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, receive);
curl_easy_setopt(handle, CURLOPT_WRITEDATA, &response);

append കോൾ നൽകിയ ബൈറ്റ് എണ്ണം ഉപയോഗിക്കുന്നു. callback ഡാറ്റ null-ൽ അവസാനിക്കുന്നില്ല, ചിത്രത്തിൽ പൂജ്യം ബൈറ്റുകൾ ഉണ്ടാകാം; strlen ഉപയോഗിച്ച് അളന്നാൽ ശരീരത്തിന്റെ ഒരു ഭാഗം നഷ്ടമാകും. വ്യത്യസ്ത വലുപ്പങ്ങളുള്ള നിരവധി callback വിളികളിലൂടെയും പ്രതികരണം വരാം.

ഉപയോഗിച്ച ബൈറ്റ് എണ്ണം തിരികെ നൽകുന്നത് ആ കഷണം സ്വീകരിക്കുന്നു. വ്യത്യസ്ത എണ്ണം തിരികെ നൽകുന്നത് എഴുത്ത് പിശകിനാൽ കൈമാറ്റം അവസാനിപ്പിക്കുന്നു. എക്സെപ്ഷൻ ഗാർഡ് ഒരു അലോക്കേഷൻ പരാജയം C callback അതിർത്തിയിലൂടെ പുറത്തുപോകുന്നത് തടയുന്നു; response ഒരു പൂർണ്ണ ഫയലായി കണക്കാക്കുന്നതിന് മുമ്പ് വിളിക്കുന്നയാൾ ഇപ്പോഴും കൈമാറ്റ ഫലം പരിശോധിക്കണം.

കൈമാറ്റം പൂർത്തിയാകുന്നതുവരെ സ്ട്രിംഗ് ജീവിച്ചിരിക്കാൻ അനുവദിക്കുക. ഒരു അസിങ്ക്രോണസ് സോക്കറ്റ് എഴുത്ത് പിന്നീട് അതിന്റെ ഉള്ളടക്കം കൈമാറുന്നുവെങ്കിൽ, ആ എഴുത്തും പൂർത്തിയാകുന്നതുവരെ ആ ബൈറ്റുകൾ ജീവിച്ചിരിക്കാൻ അനുവദിക്കുക. വലിയ പ്രതികരണങ്ങൾക്ക്, മുഴുവൻ ശരീരവും കൂട്ടിച്ചേർക്കുന്നതിനേക്കാൾ പരിമിതമായ സ്ട്രീമിംഗ് ക്രമീകരണം അഭികാമ്യമാണ്.