WebStream.hpp

#ifndef HAVE_WEB_STREAM_H
#define HAVE_WEB_STREAM_H 1

#include <cstdio>
#include <iosfwd>
#include <streambuf>
#include <istream>
#include <ostream>

#include <fcntl.h>
#include <curl/curl.h>



namespace mico
{
    namespace io
    {

        enum URLMode {
            URL_MODE_READ, URL_MODE_WRITE
        };


        class WebStreambufBase : public std::streambuf
        {

            // cURL callbacks; declared here so we can friend them
            static size_t read_callback(void *ptr, size_t size, size_t nmemb, void *device);
            static size_t write_callback(void *ptr, size_t size, size_t nmemm, void *device);

        protected:

            typedef union {
                CURL *curl;
                FILE *file;
            } handle_t;

            URLMode mode;

            handle_t handle;

            CURLM *multi_handle;

            int running_handles;

            char* buffer;           
            int buffer_size;        
            char* buffer_position;  

            bool finishing;         
            bool waiting;           


            void loop();            



        public:

            WebStreambufBase(const char* url, URLMode mode, int bufsize);


            virtual ~WebStreambufBase();


        private:

            WebStreambufBase(const WebStreambufBase & other);


            WebStreambufBase & operator=(WebStreambufBase other);

        };


        class WebIStreambuf : public WebStreambufBase {

        public:

            WebIStreambuf(const char* url) : WebStreambufBase(url, URL_MODE_READ, CURL_MAX_WRITE_SIZE) {};


        private:

            std::streambuf::int_type underflow();

            WebIStreambuf(const WebIStreambuf & other);


            WebIStreambuf & operator=(WebIStreambuf other);

        };


        class WebOStreambuf : public WebStreambufBase {

        public:

            WebOStreambuf(const char* url) : WebStreambufBase(url, URL_MODE_WRITE, CURL_MAX_WRITE_SIZE) {};

        private:

            std::streambuf::int_type overflow(std::streambuf::int_type c);

            int sync();

            WebOStreambuf(const WebOStreambuf & other);


            WebOStreambuf & operator=(WebOStreambuf other);

        };

        class web_ostream : public std::ostream {
        public:
            web_ostream(const char* url) : std::ostream(new WebOStreambuf(url)) {};

            web_ostream(std::string url) : std::ostream(new WebOStreambuf(url.c_str())) {};

            ~web_ostream() { rdbuf()->pubsync(); delete rdbuf(); };
        };


        class web_istream : public std::istream {
        public:
            web_istream(const char* url) : std::istream(new WebIStreambuf(url)) {};

            web_istream(std::string url) : std::istream(new WebIStreambuf(url.c_str())) {};

            ~web_istream() { delete rdbuf(); };
        };

        int removeFtpFile(const char* url);

        namespace {
            static size_t write_callback(void *ptr, size_t size, size_t nmemb, void *_device);
        }
    }
}

#endif