include/eq/client/config.h

/* Copyright (c) 2005-2014, Stefan Eilemann <eile@equalizergraphics.com>
 *                    2010, Cedric Stalder <cedric Stalder@gmail.com>
 *               2011-2012, 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/client/api.h>
#include <eq/client/types.h>

#include <eq/fabric/config.h>        // base class
#include <co/objectHandler.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 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;

    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 virtual void setLatency( const uint32_t latency );

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

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

    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 virtual uint32_t mapObjectNB( co::Object* object,
                                         const uint128_t& id,
                                         const uint128_t& version,
                                         co::NodePtr master );

    EQ_API virtual bool mapObjectSync( const uint32_t requestID );

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

    EQ_API f_bool_t syncObject( co::Object* object, co::NodePtr master,
                                const uint128_t& id,
                          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();


#ifndef EQ_2_0_API

    EQ_API const ConfigEvent* nextEvent();

    EQ_API const ConfigEvent* tryNextEvent();
#endif

    EQ_API void sendEvent( ConfigEvent& event );

    EQ_API virtual bool handleEvent( const ConfigEvent* event );

    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 bool checkEvent() const;

    EQ_API virtual void handleEvents();

    void addStatistic( const uint32_t originator, const Statistic& stat );

    void setupMessagePump( Pipe* pipe );

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

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

    EQ_API virtual void notifyAttached(); 
    EQ_API virtual void notifyDetach(); 

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

private:
    detail::Config* const _impl;

    void _frameStart();
    friend class Node;

    bool _needsLocalSync() const;

    bool _handleNewEvent( EventICommand& command );
    bool _handleEvent( const Event& event );
    const ConfigEvent* _convertEvent( co::ObjectICommand command );

    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