http_client.hpp

#ifndef HAVE_HTTP_CLIENT_H
#define HAVE_HTTP_CLIENT_H 1

#include <string>
#include <map>
#include <iostream>


struct curl_slist;

namespace mico {
    namespace http {

        enum Method {
            GET, POST, PUT, DELETE
        };


        class Body {

            friend class Request;
            friend class HTTPClient;
            friend size_t write_callback(void *ptr, size_t size, size_t nmemm, void *response);
            friend size_t read_callback(void *ptr, size_t size, size_t nmemb, void *request);

        private:
            char*       ptr;
            size_t      length;
            std::string type;
            bool        managed;
            size_t      pos;    // internal use by read_callback

            Body() : ptr(NULL), length(0), managed(false) {};

        public:

            Body(char* ptr, size_t length, const std::string& content_type) : ptr(ptr), length(length), type(content_type), managed(false), pos(0) {};
            Body(const std::string& data, const std::string& content_type);
            ~Body();


            const char* getContent() const { return ptr; };

            size_t getContentLength() const { return length; };

            const std::string& getContentType() const { return type; };

        };


        class Message {
            friend class HTTPClient;
            friend std::ostream& operator<<(std::ostream& os, const Message& req);
            friend std::istream& operator>>(std::istream& is, const Message& req);

            typedef std::map<std::string,std::string> header_map;

        protected:

            // headers
            header_map  headers;

            // optional request body
            Body*       body;

        public:

            Message() : body(NULL) { headers["Expect"]=""; };
            virtual ~Message();

            inline const std::string& getHeader(const std::string hdr) const { return headers.at(hdr); };


            inline const Body* getBody() const { return body; };



            curl_slist* getCurlHeaders();

            void setCurlHeaders(curl_slist* hdr);

        };



        class Request : public Message{

            friend std::ostream& operator<<(std::ostream& os, const Request& req);
            friend std::istream& operator>>(std::istream& is, const Request& req);

            friend size_t read_callback(void *ptr, size_t size, size_t nmemb, void *request);

        private:
            // request type to send
            Method type;

            // request URL
            std::string url;


        public:

            Request(Method type, std::string url) : Message(), type(type), url(url) {};

            inline Method getMethod() const { return type; };

            inline const std::string& getURL() const { return url; }

            inline Request& setHeader(const std::string hdr, const std::string value) { headers[hdr] = value; return *this; };


            inline Request& delHeader(const std::string hdr) { headers.erase(hdr); return *this; };

            Request& setBody(char *ptr, size_t length, const std::string content_type);


            Request& setBody(const std::string data, const std::string content_type);


            inline Request& setBody(Body& body) { return setBody(body.ptr, body.length, body.type); };



        };



        class Response : public Message {
            friend size_t header_callback(char *buffer, size_t size, size_t nitems, void *response);
            friend size_t write_callback(void *ptr, size_t size, size_t nmemm, void *response);

            friend class HTTPClient;

        private:
            long status;

        public:
            Response() : Message() {};


            long getStatus() const { return status; };

        };


        class HTTPClient {

        public:
            HTTPClient();
            ~HTTPClient();


            Response* execute(Request& req);

        };


        std::ostream& operator<<(std::ostream& os, const Message& req);
        std::ostream& operator<<(std::ostream& os, const Request& req);
        std::ostream& operator<<(std::ostream& os, const Response& resp);
        std::istream& operator>>(std::istream& is, const Message& req);
        std::istream& operator>>(std::istream& is, const Request& req);


    }
}


#endif