fabric/pipe.h

/* Copyright (c) 2010-2015, Stefan Eilemann <eile@equalizergraphics.com>
 *                          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 EQFABRIC_PIPE_H
#define EQFABRIC_PIPE_H

#include <eq/fabric/object.h>        // base class
#include <eq/fabric/pixelViewport.h> // property
#include <eq/fabric/types.h>

namespace eq
{
namespace fabric
{
template< class N, class P, class W, class V > class Pipe : public Object
{
public:
    typedef std::vector< W* >  Windows;

    N*       getNode()       { return _node; }
    const N* getNode() const { return _node; }

    const Windows& getWindows() const { return _windows; }

    uint32_t getPort() const { return _port; }

    EQFABRIC_INL void setPort( const uint32_t port ); 

    uint32_t getDevice() const { return _device; }

    EQFABRIC_INL void setDevice( const uint32_t device ); 

    const PixelViewport& getPixelViewport() const { return _data.pvp; }

    EQFABRIC_INL void setPixelViewport( const PixelViewport& pvp );

    void notifyPixelViewportChanged();

    EQFABRIC_INL PipePath getPath() const;

    EQFABRIC_INL VisitorResult accept( V& visitor );

    EQFABRIC_INL VisitorResult accept( V& visitor ) const;

    enum IAttribute
    {
        // Note: also update string array initialization in pipe.cpp
        IATTR_HINT_THREAD,   
        IATTR_HINT_AFFINITY, 
        IATTR_LAST,
        IATTR_ALL = IATTR_LAST + 5
    };

    EQFABRIC_INL void setIAttribute( const IAttribute attr,
                                     const int32_t value );

    int32_t getIAttribute( const IAttribute attr ) const
    { return _iAttributes[attr]; }

    bool isThreaded() const
    { return (getIAttribute( IATTR_HINT_THREAD ) == 1 ); }

    EQFABRIC_INL static const std::string& getIAttributeString(
        const IAttribute attr );

    EQFABRIC_INL virtual void backup(); 
    EQFABRIC_INL virtual void restore(); 
    void create( W** window ); 
    void release( W* window ); 
    virtual void output( std::ostream& ) const {} 

    EQFABRIC_INL virtual uint128_t commit( const uint32_t incarnation =
                                           CO_COMMIT_NEXT );

protected:
    explicit Pipe( N* parent );
    EQFABRIC_INL virtual ~Pipe( ); 

    virtual void attach( const uint128_t& id,
                         const uint32_t instanceID ); 

    EQFABRIC_INL virtual void serialize( co::DataOStream& os,
                                         const uint64_t dirtyBits );
    EQFABRIC_INL virtual void deserialize( co::DataIStream& is,
                                           const uint64_t dirtyBits );

    EQFABRIC_INL virtual void notifyDetach(); 

    EQFABRIC_INL virtual void setDirty( const uint64_t bits );

    virtual ChangeType getChangeType() const { return UNBUFFERED; }

    W* _findWindow( const uint128_t& id ); 

    enum DirtyBits
    {
        DIRTY_ATTRIBUTES      = Object::DIRTY_CUSTOM << 0,
        DIRTY_WINDOWS         = Object::DIRTY_CUSTOM << 1,
        DIRTY_PIXELVIEWPORT   = Object::DIRTY_CUSTOM << 2,
        DIRTY_MEMBER          = Object::DIRTY_CUSTOM << 3,
        DIRTY_PIPE_BITS =
        DIRTY_ATTRIBUTES | DIRTY_WINDOWS | DIRTY_PIXELVIEWPORT |
        DIRTY_MEMBER | DIRTY_OBJECT_BITS
    };

    virtual uint64_t getRedistributableBits() const
        { return DIRTY_PIPE_BITS; }

private:
    N* const _node;

    Windows _windows;

    int32_t _iAttributes[IATTR_ALL];

    uint32_t _port;

    uint32_t _device;

    struct BackupData
    {
        PixelViewport pvp;
    }
        _data, _backup;

    struct Private;
    Private* _private; // placeholder for binary-compatible changes

    void _addWindow( W* window );
    EQFABRIC_INL bool _removeWindow( W* window );
    template< class, class, class, class > friend class Window;

    bool _mapNodeObjects() { return _node->_mapNodeObjects(); }

    typedef co::CommandFunc< Pipe< N, P, W, V > > CmdFunc;
    bool _cmdNewWindow( co::ICommand& command );
    bool _cmdNewWindowReply( co::ICommand& command );
};

template< class N, class P, class W, class V > EQFABRIC_INL
std::ostream& operator << ( std::ostream&, const Pipe< N, P, W, V >& );
}
}

#endif // EQFABRIC_PIPE_H