include/eq/client/config.h

/* Copyright (c) 2005-2013, 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 UUID& id,
                                const uint128_t& version = co::VERSION_OLDEST );


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

        EQ_API virtual uint32_t mapObjectNB( co::Object* object, const UUID& 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 void releaseObject( co::Object* object );

        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 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 UUID& 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( const uint32_t finishedFrame );

        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