/home/mhx/git/github/libmoost/include/moost/murcl/response.hpp

Go to the documentation of this file.

/* vim:set ts=3 sw=3 sts=3 et: */
#ifndef FM_LAST_MOOST_MURCL_RESPONSE_HPP__
#define FM_LAST_MOOST_MURCL_RESPONSE_HPP__

#include<string>

#include <curl/curl.h>

namespace moost { namespace murcl {

// This is a SHA1 of the string "response", used to validate a cast from void *
char const RESPONSE_SHA1[] = "0ec6d150549780250a9772c06b619bcc46a0e560";
size_t const RESPONSE_SHA1_LEN = sizeof(RESPONSE_SHA1)/sizeof(RESPONSE_SHA1[0]);

class response
{
public:
   struct userdata // This class MUST be a POD type (yes, Ricky, A POD!)
   {
      char sha1_[RESPONSE_SHA1_LEN];

      std::string * pdata; // this is a pointer... pointers are PODs!
   };

   response()
   {
      strncpy(userdata_.sha1_, RESPONSE_SHA1, sizeof(userdata_.sha1_));
      userdata_.pdata = &data_;
   }

   static size_t callback( char *ptr, size_t size, size_t nmemb, void *userdata)
   {
      response::userdata * prud =
         reinterpret_cast<response::userdata *>(userdata);

      // make sure we have a valid object to play with
      if(!validate(prud))
      {
         // eek, something has gone pretty badly wrong - abort, abort abort!
         return CURL_READFUNC_ABORT;
      }

      // Not majorly efficient, but simple and given this is happening as a
      // callback in a network connection with latency I think simple trumps!
      size *= nmemb;
      prud->pdata->append(ptr, size);

      return size;
   }

   std::string const & get() const
   {
      return data_;
   }

   userdata * operator()()
   {
      return &userdata_;
   }

private:
   static bool validate(userdata * prud)
   {
      // check we have a pointer to a valid response object
      return 0 == memcmp(prud, RESPONSE_SHA1, RESPONSE_SHA1_LEN);
   }

   std::string data_;
   userdata userdata_;

};

}}

#endif // FM_LAST_MOOST_MURCL_RESPONSE_HPP__