connection.h

/* Copyright (c) 2005-2013, Stefan Eilemann <eile@equalizergraphics.com>
 *                    2012, 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/referenced.h>   // base class

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

#ifdef _WIN32
#  define EQ_DEFAULT_PORT (4242)
#else
#  define EQ_DEFAULT_PORT (4242 + getuid())
#endif

namespace co
{
namespace detail { class Connection; }

    class Connection : public lunchbox::Referenced, public lunchbox::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*/ }
}

#endif //CO_CONNECTION_H