include/co/node.h

/* Copyright (c) 2005-2011, Stefan Eilemann <eile@equalizergraphics.com>
 *                    2010, Cedric Stalder <cedric.stalder@gmail.com>
 *
 * 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_NODE_H
#define CO_NODE_H

#include <co/dispatcher.h>        // base class
#include <co/connection.h>        // member - ConnectionPtr
#include <co/nodeType.h>          // for NODETYPE_CO_NODE enum
#include <co/types.h>

#include <co/base/lockable.h>         // member
#include <co/base/spinLock.h>         // member

namespace co
{
    class Node : public Dispatcher, public base::Referenced
    {
    public:
        CO_API Node();

        bool operator == ( const Node* n ) const;

        bool isConnected() const 
            { return (_state == STATE_CONNECTED || _state == STATE_LISTENING);}
        bool isClosed() const { return _state == STATE_CLOSED; }
        bool isListening() const { return _state == STATE_LISTENING; }


        bool isLocal() const { return isListening(); }

        CO_API void addConnectionDescription( ConnectionDescriptionPtr cd );
        
        CO_API bool removeConnectionDescription(ConnectionDescriptionPtr cd);

        CO_API ConnectionDescriptions getConnectionDescriptions() const;

        ConnectionPtr getConnection() const { return _outgoing; }

        ConnectionPtr getMulticast();

        bool send( const Packet& packet )
            {
                ConnectionPtr connection = _getConnection();
                if( !connection )
                    return false;
                return connection->send( packet );
            }

        bool send( Packet& packet, const std::string& string )
            {
                ConnectionPtr connection = _getConnection();
                if( !connection )
                    return false;
                return connection->send( packet, string );
            }

        template< class T >
        bool send( Packet& packet, const std::vector<T>& data )
            {
                ConnectionPtr connection = _getConnection();
                if( !connection )
                    return false;
                return connection->send( packet, data );
            }

        bool send( Packet& packet, const void* data, const uint64_t size )
            {
                ConnectionPtr connection = _getConnection();
                if( !connection )
                    return false;
                return connection->send( packet, data, size );
            }

        bool multicast( const Packet& packet )
            {
                ConnectionPtr connection = getMulticast();
                if( !connection )
                    return false;
                return connection->send( packet );
            }

        const NodeID& getNodeID() const { return _id; }

        CO_API std::string serialize() const;
        CO_API bool deserialize( std::string& data );

    protected:
        CO_API virtual ~Node();

        virtual uint32_t getType() const { return NODETYPE_CO_NODE; }

        CO_API virtual NodePtr createNode( const uint32_t type );

    private:
        enum State
        {
            STATE_CLOSED,    
            STATE_CONNECTED, 
            STATE_LISTENING  
        };

        friend CO_API std::ostream& operator << ( std::ostream& os, 
                                                     const Node& node );
        friend CO_API std::ostream& operator << ( std::ostream&,
                                                     const State );
        friend class LocalNode;

        NodeID _id;

        State _state;

        ConnectionPtr _outgoing;

        base::Lockable< ConnectionPtr > _outMulticast;

        struct MCData
        {
            ConnectionPtr connection;
            NodePtr       node;
        };
        typedef std::vector< MCData > MCDatas;

        MCDatas _multicasts;

        base::Lockable< ConnectionDescriptions, base::SpinLock >
            _connectionDescriptions;

        ConnectionPtr _getConnection()
            {
                ConnectionPtr connection = _outgoing;
                if( _state == STATE_CONNECTED || _state == STATE_LISTENING )
                    return connection;
                EQUNREACHABLE;
                return 0;
            }
    };

    CO_API std::ostream& operator << ( std::ostream& os, const Node& node );
    CO_API std::ostream& operator << ( std::ostream&, const Node::State );
}

#endif // CO_NODE_H