fabric/config.h

/* Copyright (c) 2005-2015, Stefan Eilemann <eile@equalizergraphics.com>
 *                          Cedric Stalder <cedric Stalder@gmail.com>
 *                          Daniel Nachbaur <danielnachbaur@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_CONFIG_H
#define EQFABRIC_CONFIG_H

#include <eq/fabric/api.h>
#include <eq/fabric/object.h> // DIRTY_CUSTOM enum
#include <eq/fabric/types.h>  // typedefs

namespace eq
{
namespace fabric
{
template <class S, class C, class O, class L, class CV, class N, class V>
// cppcheck-suppress noConstructor
class Config : public Object
{
public:
    typedef std::vector<O*> Observers; 
    typedef std::vector<L*> Layouts;   
    typedef std::vector<CV*> Canvases; 
    typedef std::vector<N*> Nodes;     

    EQFABRIC_INL lunchbox::RefPtr<S> getServer();

    EQFABRIC_INL lunchbox::RefPtr<const S> getServer() const;

    const Observers& getObservers() const { return _observers; }
    const Layouts& getLayouts() const { return _layouts; }
    const Canvases& getCanvases() const { return _canvases; }

    EQFABRIC_INL uint32_t getTimeout() const;

    const Nodes& getNodes() const { return _nodes; }
    EQFABRIC_INL N* findAppNode();             
    EQFABRIC_INL const N* findAppNode() const; 

    EQFABRIC_INL VisitorResult accept(V& visitor);

    EQFABRIC_INL VisitorResult accept(V& visitor) const;

    template <typename T>
    EQFABRIC_INL T* find(const uint128_t& id);

    template <typename T>
    EQFABRIC_INL const T* find(const uint128_t& id) const;

    template <typename T>
    EQFABRIC_INL T* find(const std::string& name);

    template <typename T>
    EQFABRIC_INL const T* find(const std::string& name) const;

    O* getObserver(const ObserverPath& path);

    L* getLayout(const LayoutPath& path);

    CV* getCanvas(const CanvasPath& path);

    template <typename T>
    void find(const uint128_t& id, T** result);

    template <typename T>
    void find(const std::string& name, const T** result) const;

    virtual void updateCanvas(CV*) { /* NOP */}

    virtual void exitCanvas(CV*) { /* NOP */}

    // Note: also update string array initialization in config.ipp

    enum FAttribute
    {
        FATTR_EYE_BASE, 
        FATTR_VERSION,  
        FATTR_LAST,
        FATTR_ALL = FATTR_LAST + 5
    };

    enum IAttribute
    {
        IATTR_ROBUSTNESS, 
        IATTR_LAST,
        IATTR_ALL = IATTR_LAST + 5
    };

    void setFAttribute(const FAttribute attr, const float value)
    {
        _fAttributes[attr] = value;
    }
    void setIAttribute(const IAttribute attr, const int32_t value)
    {
        _iAttributes[attr] = value;
    }

    float getFAttribute(const FAttribute attr) const
    {
        return _fAttributes[attr];
    }

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

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

    virtual void setLatency(const uint32_t latency);

    uint32_t getLatency() const { return _data.latency; }
    EQFABRIC_INL virtual void restore();

    virtual void output(std::ostream&) const {} 
    void create(O** observer);                  
    void release(O* observer);                  
    void create(L** layout);                    
    void release(L* layout);                    
    void create(CV** canvas);                   
    void release(CV* canvas);                   
    void create(N** node);                      
    void release(N* node);                      

protected:
    EQFABRIC_INL explicit Config(lunchbox::RefPtr<S> parent);

    EQFABRIC_INL virtual ~Config();

    EQFABRIC_INL 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();

    virtual void _removeChild(const uint128_t&) { LBUNIMPLEMENTED; }
    template <class, class, class, class, class, class>
    friend class Server;

    void setAppNodeID(const co::NodeID& nodeID); 

    const co::NodeID& getAppNodeID() const { return _appNodeID; }
    EQFABRIC_INL EventOCommand sendError(co::NodePtr node, const uint32_t event,
                                         const Error& error);

    virtual void changeLatency(const uint32_t) { /* NOP */} 
    virtual bool mapViewObjects() const { return false; }   
    virtual bool mapNodeObjects() const { return false; }   

    virtual VisitorResult _acceptCompounds(V&) { return TRAVERSE_CONTINUE; }
    virtual VisitorResult _acceptCompounds(V&) const
    {
        return TRAVERSE_CONTINUE;
    }
    template <class C2, class V2>
    friend VisitorResult _acceptImpl(C2*, V2&);

    N* _findNode(const uint128_t& id); 

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

private:
    lunchbox::RefPtr<S> _server;

    float _fAttributes[FATTR_ALL];

    int32_t _iAttributes[IATTR_ALL];

    Observers _observers;

    Layouts _layouts;

    Canvases _canvases;

    Nodes _nodes;

    co::NodeID _appNodeID;

    struct BackupData
    {
        BackupData()
            : latency(1)
        {
        }

        uint32_t latency;
    } _data, _backup;

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

    enum DirtyBits
    {
        DIRTY_MEMBER = Object::DIRTY_CUSTOM << 0,
        DIRTY_LATENCY = Object::DIRTY_CUSTOM << 1,
        DIRTY_ATTRIBUTES = Object::DIRTY_CUSTOM << 2,
        DIRTY_NODES = Object::DIRTY_CUSTOM << 3,
        DIRTY_OBSERVERS = Object::DIRTY_CUSTOM << 4,
        DIRTY_LAYOUTS = Object::DIRTY_CUSTOM << 5,
        DIRTY_CANVASES = Object::DIRTY_CUSTOM << 6,
        DIRTY_CONFIG_BITS = DIRTY_MEMBER | DIRTY_ATTRIBUTES | DIRTY_OBSERVERS |
                            DIRTY_LAYOUTS | DIRTY_CANVASES | DIRTY_NODES |
                            DIRTY_LATENCY
    };

    virtual uint64_t getRedistributableBits() const
    {
        return DIRTY_CONFIG_BITS;
    }

    template <class, class>
    friend class Observer;
    void _addObserver(O* observer);
    bool _removeObserver(O* observer);

    template <class, class, class>
    friend class Layout;
    void _addLayout(L* layout);
    bool _removeLayout(L* layout);

    template <class, class, class, class>
    friend class Canvas;
    void _addCanvas(CV* canvas);
    bool _removeCanvas(CV* canvas);

    template <class, class, class, class>
    friend class Node;
    void _addNode(N* node);
    EQFABRIC_INL bool _removeNode(N* node);

    typedef co::CommandFunc<Config<S, C, O, L, CV, N, V>> CmdFunc;
    bool _cmdNewLayout(co::ICommand& command);
    bool _cmdNewCanvas(co::ICommand& command);
    bool _cmdNewObserver(co::ICommand& command);
    bool _cmdNewEntityReply(co::ICommand& command);
};

template <class S, class C, class O, class L, class CV, class N, class V>
EQFABRIC_INL std::ostream& operator<<(
    std::ostream& os, const Config<S, C, O, L, CV, N, V>& config);
}
}
#endif // EQFABRIC_CONFIG_H