connection.h

/* Copyright (c) 2005-2014, Stefan Eilemann <eile@equalizergraphics.com>
 *               2012-2014, 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 <lunchbox/bitOperation.h> // used inline
#include <lunchbox/referenced.h>   // base class
#include <boost/noncopyable.hpp>   // base class

#include <sys/types.h>
#include <string.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& );
}

namespace lunchbox
{
template<> inline void byteswap( co::Connection*& ) { /*NOP*/ }
template<> inline void byteswap( co::ConnectionPtr& ) { /*NOP*/ }
}

#endif //CO_CONNECTION_H