URLStream.hpp

#ifndef HAVE_URL_STREAM_H
#define HAVE_URL_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 URLType {
            URL_TYPE_FILE = 1,
            URL_TYPE_HTTP = 2,
            URL_TYPE_FTP  = 3
        };

        enum URLMode {
            URL_MODE_READ, URL_MODE_WRITE
        };


        class URLStreambufBase : 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;

            URLType type;
            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:

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


            virtual ~URLStreambufBase();


        private:

            URLStreambufBase(const URLStreambufBase& other);


            URLStreambufBase& operator=(URLStreambufBase other);

        };


        class URLIStreambuf : public URLStreambufBase {

        public:

            URLIStreambuf(const char* url) : URLStreambufBase(url, URL_MODE_READ, CURL_MAX_WRITE_SIZE) {};


        private:

            int underflow();

            URLIStreambuf(const URLIStreambuf& other);


            URLIStreambuf& operator=(URLIStreambuf other);

        };


        class URLOStreambuf : public URLStreambufBase {

        public:

            URLOStreambuf(const char* url) : URLStreambufBase(url, URL_MODE_WRITE, CURL_MAX_WRITE_SIZE) {};

        private:

            int overflow(int c);

            int sync();

            URLOStreambuf(const URLOStreambuf& other);


            URLOStreambuf& operator=(URLOStreambuf other);

        };

        class url_ostream : public std::ostream {
        public:
            url_ostream(const char* url) : std::ostream(new URLOStreambuf(url)) {};

            url_ostream(std::string url) : std::ostream(new URLOStreambuf(url.c_str())) {};

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


        class url_istream : public std::istream {
        public:
            url_istream(const char* url) : std::istream(new URLIStreambuf(url)) {};

            url_istream(std::string url) : std::istream(new URLIStreambuf(url.c_str())) {};

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


        // TODO: deleting of content parts binary data from disk/FTP

    }
}

#endif