abstract_socket.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2013 Evidence Srl - www.evidence.eu.com
 *
 * Boost Software License - Version 1.0 - August 17th, 2003
 *
 * Permission is hereby granted, free of charge, to any person or organization
 * obtaining a copy of the software and accompanying documentation covered by
 * this license (the "Software") to use, reproduce, display, distribute,
 * execute, and transmit the Software, and to prepare derivative works of the
 * Software, and to permit third-parties to whom the Software is furnished to
 * do so, all subject to the following:
 * 
 * The copyright notices in the Software and this entire statement, including
 * the above license grant, this restriction and the following disclaimer,
 * must be included in all copies of the Software, in whole or in part, and
 * all derivative works of the Software, unless such copies or derivative
 * works are solely in the form of machine-executable object code generated by
 * a source language processor.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
 * SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
 * FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#ifndef ABSTRACT_SOCKET_HPP_
#define ABSTRACT_SOCKET_HPP_

#include <unistd.h>
#include <mutex>
#include <stdexcept>
#include <array>
#include <thread>

#include "abstract_system_socket.hpp"
#include "logger.hpp"
#include "platform.hpp"

namespace net {

/** @brief Structure to avoid issues when giving buffers to AbstractSocket.
 *
 * This structure allows to avoid issues about templates when giving a buffer
 * to AbstractSocket. It is not meant to be directly used by the user.
 * The user must only use buffer(...).
 */
struct __buffer {
        /// Pointer to data in memory
        void* ptr_;

        /// Size (in bytes) of data
        std::size_t size_;
};

/**
 * @brief Function to pass a std::array to AbstractSocket
 *
 * @param reference to a std::array<char>
 * @return a __buffer structure
 */
template<std::size_t N>
inline __buffer buffer(std::array<char, N>& buf)
{
        return __buffer {reinterpret_cast<void*>(buf.data()), buf.size()};
}

/**
 * @brief Base abstract class for protocols.
 *
 * This is the base abstract class for protocols. Any supported protocol
 * must inherit from this class.
 */
class AbstractSocket {
public:

        /**
         * @brief Close the socket
         *
         * Method to close the socket. Currently, there is no mechanism
         * to re-open a closed socket.
         *
         * @return true in case of success; false otherwise
         */
        inline bool close()
        {
                return socket_->close();
        }

        /**
         * @brief get the socket
         *
         * This method is used to let derived classes of AbstractSocket invoke
         * specific protocol-dependent functions (e.g., accept()).
         *
         * @return the socket used by this instance of the class
         */
        inline AbstractSystemSocket* getSocket()
        {
                return socket_.get();
        }

        int receive (__buffer buf, std::size_t size);
        int send (__buffer buf, std::size_t size);

protected:
        /**
         * @brief Constructor
         *
         * Constructor is protected because only derived classes
         * can construct this class.
         * The object is constructed through net::createSocket(),
         * which creates a platform-dependent socket.
         * @param the protocol type
         */
        AbstractSocket(const protocol& prot):
                socket_{createSocket(prot)} {}


        /**
         * @brief Pointer to the platform-dependent socket
         *
         * The platform-dependent socket
         */
        std::unique_ptr<AbstractSystemSocket>  socket_;

private:

        int __receive (void* buffer, size_t size);
        int __send (const void* buffer, size_t size);

        /**
         * @brief Thread for asynchronous receive operations
         */
        std::unique_ptr<std::thread> receive_worker_;

        /**
         * @brief Thread for asynchronous send operations
         */
        std::unique_ptr<std::thread> send_worker_;

        /**
         * @brief Mutex for synchronization with asynchronous receive operations.
         */
        std::mutex receive_lock_;
        
        /**
         * @brief Mutex for synchronization with asynchronous send operations.
         */
        std::mutex send_lock_;
};

} // net

#endif // ABSTRACT_SOCKET_HPP_