include/eq/fabric/node.h

/* Copyright (c) 2010-2011, Stefan Eilemann <eile@eyescale.ch>
 *               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 EQFABRIC_NODE_H
#define EQFABRIC_NODE_H

#include <eq/fabric/object.h>        // base class
#include <eq/fabric/types.h>
#include <eq/fabric/visitorResult.h> // enum

namespace eq
{
namespace fabric
{
    template< class C, class N, class P, class V > class Node : public Object
    {
    public:
        typedef std::vector< P* > Pipes;

        C*       getConfig()       { return _config; }

        const C* getConfig() const { return _config; }

        const Pipes& getPipes() const { return _pipes; }

        bool isApplicationNode() const { return _isAppNode; }

        EQFABRIC_INL void setApplicationNode( const bool isAppNode );

        EQFABRIC_INL NodePath getPath() const;
        P* findPipe( const co::base::UUID& id ); 

        EQFABRIC_INL VisitorResult accept( V& visitor );

        EQFABRIC_INL VisitorResult accept( V& visitor ) const;

        // Note: also update string array initialization in node.ipp
        enum IAttribute
        {
            IATTR_THREAD_MODEL,
            IATTR_LAUNCH_TIMEOUT, 
            IATTR_LAST,
            IATTR_ALL = IATTR_LAST + 5
        };

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

        EQFABRIC_INL int32_t getIAttribute( const IAttribute attr ) const;

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

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

    protected:
        Node( C* parent );
        EQFABRIC_INL virtual ~Node();

        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; }

        enum DirtyBits
        {
            DIRTY_ATTRIBUTES      = Object::DIRTY_CUSTOM << 0,
            DIRTY_PIPES           = Object::DIRTY_CUSTOM << 1,
            DIRTY_MEMBER          = Object::DIRTY_CUSTOM << 2,
            DIRTY_NODE_BITS =
                DIRTY_ATTRIBUTES | DIRTY_PIPES | DIRTY_MEMBER |
                DIRTY_OBJECT_BITS
        };

        virtual uint64_t getRedistributableBits() const
            { return DIRTY_NODE_BITS; }

    private:
        Pipes _pipes;

        C* const _config;

        struct BackupData
        {
            BackupData();
            int32_t iAttributes[IATTR_ALL];
        }
            _data, _backup;

        bool _isAppNode; 

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

        template< class, class, class, class > friend class Pipe;
        void _addPipe( P* pipe );
        bool _removePipe( P* pipe );

        EQFABRIC_INL virtual uint32_t commitNB( const uint32_t incarnation );
        bool _mapNodeObjects() { return _config->mapNodeObjects(); }
    };

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

#endif // EQFABRIC_NODE_H