connection.h

/* Copyright (c) 2005-2017, Stefan Eilemann <eile@equalizergraphics.com>
 *                          Daniel Nachbaur <danielnachbaur@gmail.com>
 *
 * This file is part of Collage <https://github.com/Eyescale/Collage>
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef CO_CONNECTION_H
#define CO_CONNECTION_H

#include <co/api.h>
#include <co/types.h>

#include <boost/noncopyable.hpp>   // base class
#include <lunchbox/bitOperation.h> // used inline
#include <lunchbox/referenced.h>   // base class

#include <string.h>
#include <sys/types.h>
#include <vector>

namespace co
{
namespace detail
{
class Connection;
}

class Connection : public lunchbox::Referenced, public boost::noncopyable
{
public:
    enum State 
    {
        STATE_CLOSED,     
        STATE_CONNECTING, 
        STATE_CONNECTED,  
        STATE_LISTENING,  
        STATE_CLOSING     
    };

    CO_API static ConnectionPtr create(ConnectionDescriptionPtr desc);

    CO_API State getState() const;

    bool isClosed() const { return getState() == STATE_CLOSED; }
    bool isClosing() const { return getState() == STATE_CLOSING; }
    bool isConnected() const { return getState() == STATE_CONNECTED; }
    bool isListening() const { return getState() == STATE_LISTENING; }
    CO_API bool isMulticast() const;

    CO_API ConstConnectionDescriptionPtr getDescription() const;

    bool operator==(const Connection& rhs) const;

    virtual bool connect() { return false; }
    virtual bool listen() { return false; }
    virtual void close() {}

    void addListener(ConnectionListener* listener);

    void removeListener(ConnectionListener* listener);

    virtual void acceptNB() { LBUNIMPLEMENTED; }
    virtual ConnectionPtr acceptSync()
    {
        LBUNIMPLEMENTED;
        return 0;
    }

    CO_API void recvNB(BufferPtr buffer, const uint64_t bytes);

    CO_API bool recvSync(BufferPtr& buffer, const bool block = true);

    BufferPtr resetRecvData(); 


    CO_API bool send(const void* buffer, const uint64_t bytes,
                     const bool isLocked = false);

    CO_API void lockSend() const;

    CO_API void unlockSend() const;

    virtual void finish() {}

#ifdef _WIN32
    typedef void* Notifier;
#else
    typedef int Notifier;
#endif

    virtual Notifier getNotifier() const = 0;

protected:
    Connection();

    virtual ~Connection();

    enum ReadStatus 
    {
        READ_TIMEOUT = -2,
        READ_ERROR = -1
        // >= 0: nBytes read
    };

    virtual void readNB(void* buffer, const uint64_t bytes) = 0;

    virtual int64_t readSync(void* buffer, const uint64_t bytes,
                             const bool block) = 0;

    virtual int64_t write(const void* buffer, const uint64_t bytes) = 0;

    CO_API void _setDescription(ConnectionDescriptionPtr description);

    CO_API void _setState(const State state); 

    CO_API ConnectionDescriptionPtr _getDescription();

private:
    detail::Connection* const _impl;
};

CO_API std::ostream& operator<<(std::ostream&, const Connection&);
}

#endif // CO_CONNECTION_H