include/eq/fabric/node.h

/* Copyright (c) 2010-2014, 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>

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 uint128_t& 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_HINT_AFFINITY,
        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 {} 
    EQFABRIC_INL virtual uint128_t commit( const uint32_t incarnation =
                                           CO_COMMIT_NEXT );

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; 

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

    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