C++ std::string ಗೆ libcurl ನ ಬೈನರಿ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಸ್ವೀಕರಿಸಿ

ಪ್ರಾಕ್ಸಿಯು 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-terminated ಅಲ್ಲ, ಮತ್ತು ಚಿತ್ರದಲ್ಲಿ ಶೂನ್ಯ ಬೈಟ್‌ಗಳಿರಬಹುದು; strlen ನಿಂದ ಅಳೆಯುವುದು ದೇಹದ ಭಾಗವನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತದೆ. ಪ್ರತಿಕ್ರಿಯೆಯು ವಿವಿಧ ಗಾತ್ರದ ಅನೇಕ callback ಕರೆಗಳ ಮೂಲಕವೂ ಬರಬಹುದು.

ಬಳಸಿದ ಬೈಟ್ ಎಣಿಕೆಯನ್ನು ಹಿಂತಿರುಗಿಸುವುದು ತುಣುಕನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. ಬೇರೆ ಎಣಿಕೆಯನ್ನು ಹಿಂತಿರುಗಿಸುವುದು ಬರವಣಿಗೆ ದೋಷದೊಂದಿಗೆ ವರ್ಗಾವಣೆಯನ್ನು ನಿಲ್ಲಿಸುತ್ತದೆ. ವಿನಾಯಿತಿ ಕಾವಲುಗಾರವು ಹಂಚಿಕೆ ವೈಫಲ್ಯವು C callback ಮಿತಿಯಿಂದ ಹೊರಬರದಂತೆ ತಡೆಯುತ್ತದೆ; ಕರೆಗಾರನು response ಅನ್ನು ಪೂರ್ಣ ಫೈಲ್ ಎಂದು ಪರಿಗಣಿಸುವ ಮೊದಲು ವರ್ಗಾವಣೆ ಫಲಿತಾಂಶವನ್ನು ಇನ್ನೂ ಪರಿಶೀಲಿಸಬೇಕು.

ವರ್ಗಾವಣೆ ಮುಗಿಯುವವರೆಗೆ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಜೀವಂತವಾಗಿರಿಸಿ. ಒಂದು ಅಸಿಂಕ್ರೋನಸ್ ಸಾಕೆಟ್ ಬರವಣಿಗೆ ನಂತರ ಅದರ ವಿಷಯವನ್ನು ಮುಂದೆ ರವಾನಿಸಿದರೆ, ಆ ಬರವಣಿಗೆಯೂ ಪೂರ್ಣಗೊಳ್ಳುವವರೆಗೆ ಆ ಬೈಟ್‌ಗಳನ್ನು ಜೀವಂತವಾಗಿರಿಸಿ. ದೊಡ್ಡ ಪ್ರತಿಕ್ರಿಯೆಗಳಿಗೆ, ಇಡೀ ದೇಹವನ್ನು ಸಂಗ್ರಹಿಸುವುದಕ್ಕಿಂತ ಸೀಮಿತ ಸ್ಟ್ರೀಮಿಂಗ್ ವ್ಯವಸ್ಥೆ ಉತ್ತಮ.