config.h

/* Copyright (c) 2005-2017, 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 EQ_CONFIG_H
#define EQ_CONFIG_H

#include <eq/api.h>
#include <eq/types.h>

#include <co/objectHandler.h> // base class
#include <eq/fabric/config.h> // base class

namespace eq
{
namespace detail
{
class Config;
}

class Config : public fabric::Config<Server, Config, Observer, Layout, Canvas,
                                     Node, ConfigVisitor>,
               public co::ObjectHandler
{
public:
    typedef fabric::Config<Server, Config, Observer, Layout, Canvas, Node,
                           ConfigVisitor>
        Super; 

    EQ_API explicit Config(ServerPtr parent);

    EQ_API virtual ~Config();

    EQ_API ClientPtr getClient();

    EQ_API ConstClientPtr getClient() const;

    EQ_API co::NodePtr getApplicationNode();

    EQ_API co::CommandQueue* getMainThreadQueue();    
    EQ_API co::CommandQueue* getCommandThreadQueue(); 

    EQ_API uint32_t getCurrentFrame() const;

    EQ_API uint32_t getFinishedFrame() const;

    EQ_API GLStats::Data getStatistics() const;

    EQ_API bool isRunning() const;

    EQ_API void stopRunning();

    EQ_API int64_t getTime() const;

    EQ_API MessagePump* getMessagePump();

    const Channel* findChannel(const std::string& name) const
    {
        return find<Channel>(name);
    }

    EQ_API virtual bool init(const uint128_t& initID);

    EQ_API virtual bool exit();

    EQ_API bool update();

    EQ_API void setLatency(const uint32_t latency) override;

    EQ_API bool registerObject(co::Object* object) override;

    EQ_API void deregisterObject(co::Object* object) override;

    EQ_API virtual bool mapObject(
        co::Object* object, const uint128_t& id,
        const uint128_t& version = co::VERSION_OLDEST);

    EQ_API virtual uint32_t mapObjectNB(
        co::Object* object, const uint128_t& id,
        const uint128_t& version = co::VERSION_OLDEST);

    EQ_API uint32_t mapObjectNB(co::Object* object, const uint128_t& id,
                                const uint128_t& version,
                                co::NodePtr master) override;

    EQ_API bool mapObjectSync(const uint32_t requestID) override;

    EQ_API void unmapObject(co::Object* object) override;

    EQ_API f_bool_t
        syncObject(co::Object* object, const uint128_t& id, co::NodePtr master,
                   const uint32_t instanceID = CO_INSTANCE_ALL) override;

    EQ_API virtual uint32_t startFrame(const uint128_t& frameID);

    EQ_API virtual uint32_t finishFrame();

    EQ_API virtual uint32_t finishAllFrames();

    EQ_API void releaseFrameLocal(const uint32_t frameNumber);

    EQ_API void stopFrames();


    EQ_API EventOCommand sendEvent(const uint32_t type);

    EQ_API EventOCommand sendError(const uint32_t type, const Error& error);

    EQ_API Errors getErrors();

    EQ_API EventICommand
        getNextEvent(const uint32_t timeout = LB_TIMEOUT_INDEFINITE) const;

    EQ_API virtual bool handleEvent(EventICommand command);
    EQ_API virtual bool handleEvent(EventType type, const Event& event);
    EQ_API virtual bool handleEvent(EventType type, const SizeEvent& event);
    EQ_API virtual bool handleEvent(EventType type, const PointerEvent& event);
    EQ_API virtual bool handleEvent(EventType type, const KeyEvent& event);
    EQ_API virtual bool handleEvent(const AxisEvent& event);
    EQ_API virtual bool handleEvent(const ButtonEvent& event);

    EQ_API bool checkEvent() const;

    EQ_API virtual void handleEvents();

    EQ_API virtual void addStatistic(const Statistic& stat);

    void setupMessagePump(Pipe* pipe);

    void setupServerConnections(const std::string& connectionData);

protected:
    EQ_API void attach(const uint128_t& id, const uint32_t instanceID) override;

    EQ_API void notifyAttached() override; 
    EQ_API void notifyDetach() override;   

    EQ_API void changeLatency(const uint32_t latency) override;
    EQ_API bool mapViewObjects() const override; 

private:
    detail::Config* const _impl;

    void _frameStart();
    friend class Node;

    bool _needsLocalSync() const;

    void _updateStatistics();

    void _releaseObjects();

    void _exitMessagePump();

    bool _cmdSyncClock(co::ICommand& command);
    bool _cmdCreateNode(co::ICommand& command);
    bool _cmdDestroyNode(co::ICommand& command);
    bool _cmdInitReply(co::ICommand& command);
    bool _cmdExitReply(co::ICommand& command);
    bool _cmdUpdateVersion(co::ICommand& command);
    bool _cmdUpdateReply(co::ICommand& command);
    bool _cmdReleaseFrameLocal(co::ICommand& command);
    bool _cmdFrameFinish(co::ICommand& command);
    bool _cmdSwapObject(co::ICommand& command);
};
}

#endif // EQ_CONFIG_H