callable.hpp

#ifndef NOOS_CLOUD_CALLABLE
#define NOOS_CLOUD_CALLABLE
/*
 * LICENSE HERE
 */
#include "includes.ihh"
#include <noos/cloud/asio/platform.hpp>
#include <noos/cloud/default_error_handler.hpp>
#include <noos/cloud/asio/asio_https.hpp>
#include <noos/cloud/asio/asio_http.hpp>
#include <noos/cloud/asio/platform.hpp>
#include <noos/cloud/cloud_base.hpp>
#include <noos/cloud/deserialize.hpp>
#include <noos/cloud/vision_batch.hpp>

namespace noos {
namespace cloud {

template <class cloud_type,
          bool  keep_alive   = true,
          class socket_type  = asio_https,
          class error_handle = default_error_handler>
class callable
{
public:
    using callback = typename cloud_type::callback;
    using cloud_class = cloud_type;

    cloud_type object;

    callable() = delete;
    
    callable(callable const &) = delete;

    callable & operator=(const callable &) = delete;
    
    callable & operator=(callable &&) = delete;

    callable(callback functor,
             platform = default_node);

    template <typename... parameters,
              typename = typename std::enable_if<!std::is_same<cloud_type,cloud_batch>::value,bool>>
    callable(callback functor,
             platform info,
             parameters... args);

    template <typename... parameters>
    callable(vision_batch<parameters...> arg,
             platform = default_node);

    template <typename... parameters,
              typename = typename std::enable_if<std::is_same<cloud_type,cloud_batch>::value,bool>>
    callable(const noos::object::picture & image,
             platform info,
             parameters... args);

    void send(unsigned int timeout = 2);
    void stop();
protected:
    void socket(std::function<void(std::string)> cloud_function);
    callback functor;
    platform endpoint;
    std::unique_ptr<socket_type> socket_;
    std::unique_ptr<boost::asio::streambuf> buffer_;
    std::unique_ptr<boost::asio::ip::tcp::resolver::query> query_;
    std::unique_ptr<boost::asio::io_service> io_;
    std::unique_ptr<boost::asio::ip::tcp::resolver> resol_;
};

template <class cloud_type,
          bool  keep_alive   = true,
          class socket_type  = asio_https,
          class error_handle = default_error_handler,
          class ...args,
          typename = 
                typename std::enable_if<!std::is_same<cloud_type, 
                                                      cloud_batch>::value, bool>>
callable<cloud_type,keep_alive,socket_type,error_handle> 
    call(typename cloud_type::callback functor,
         args... params)
{
    return callable<cloud_type,
                    keep_alive,
                    socket_type,
                    error_handle>(functor, default_node, params...);
}

#include "callable.tpl"
}
}
#endif