connection.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014, Peter Thorson. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the WebSocket++ Project nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#ifndef WEBSOCKETPP_TRANSPORT_STUB_CON_HPP
#define WEBSOCKETPP_TRANSPORT_STUB_CON_HPP

#include <websocketpp/transport/stub/base.hpp>

#include <websocketpp/transport/base/connection.hpp>

#include <websocketpp/logger/levels.hpp>

#include <websocketpp/common/connection_hdl.hpp>
#include <websocketpp/common/memory.hpp>
#include <websocketpp/common/platforms.hpp>

#include <string>
#include <vector>

namespace websocketpp {
namespace transport {
namespace stub {

struct timer {
    void cancel() {}
};

template <typename config>
class connection : public lib::enable_shared_from_this< connection<config> > {
public:
    typedef connection<config> type;
    typedef lib::shared_ptr<type> ptr;

    typedef typename config::concurrency_type concurrency_type;
    typedef typename config::alog_type alog_type;
    typedef typename config::elog_type elog_type;

    // Concurrency policy types
    typedef typename concurrency_type::scoped_lock_type scoped_lock_type;
    typedef typename concurrency_type::mutex_type mutex_type;

    typedef lib::shared_ptr<timer> timer_ptr;

    explicit connection(bool is_server, const lib::shared_ptr<alog_type> & alog, const lib::shared_ptr<elog_type> & elog)
      : m_alog(alog), m_elog(elog)
    {
        m_alog->write(log::alevel::devel,"stub con transport constructor");
    }

    ptr get_shared() {
        return type::shared_from_this();
    }


    void set_secure(bool value) {}


    bool is_secure() const {
        return false;
    }


    void set_uri(uri_ptr) {}


    void set_remote_endpoint(std::string value) {}


    std::string get_remote_endpoint() const {
        return "unknown (stub transport)";
    }


    connection_hdl get_handle() const {
        return connection_hdl();
    }


    timer_ptr set_timer(long duration, timer_handler handler) {
        return timer_ptr();
    }
protected:

    void init(init_handler handler) {
        m_alog->write(log::alevel::devel,"stub connection init");
        handler(make_error_code(error::not_implemented));
    }


    void async_read_at_least(size_t num_bytes, char * buf, size_t len,
        read_handler handler)
    {
        m_alog->write(log::alevel::devel, "stub_con async_read_at_least");
        handler(make_error_code(error::not_implemented), 0);
    }


    void async_write(char const * buf, size_t len, write_handler handler) {
        m_alog->write(log::alevel::devel,"stub_con async_write");
        handler(make_error_code(error::not_implemented));
    }


    void async_write(std::vector<buffer> const & bufs, write_handler handler) {
        m_alog->write(log::alevel::devel,"stub_con async_write buffer list");
        handler(make_error_code(error::not_implemented));
    }


    void set_handle(connection_hdl hdl) {}


    lib::error_code dispatch(dispatch_handler handler) {
        handler();
        return lib::error_code();
    }


    void async_shutdown(shutdown_handler handler) {
        handler(lib::error_code());
    }
private:
    // member variables!
    lib::shared_ptr<alog_type> m_alog;
    lib::shared_ptr<elog_type> m_elog;
};


} // namespace stub
} // namespace transport
} // namespace websocketpp

#endif // WEBSOCKETPP_TRANSPORT_STUB_CON_HPP