include/eq/config.h

/* Copyright (c) 2005-2011, Stefan Eilemann <eile@equalizergraphics.com>
 *                    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 EQ_CONFIG_H
#define EQ_CONFIG_H

#include <eq/commandQueue.h>  // member
#include <eq/types.h>         // typedefs

#include <eq/fabric/config.h>        // base class
#include <co/base/clock.h>           // member
#include <co/base/monitor.h>         // member
#include <co/base/spinLock.h>        // member

namespace eq
{
    class Config : public fabric::Config< Server, Config, Observer, Layout,
                                          Canvas, Node, ConfigVisitor >
    {
    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;

        co::NodePtr getApplicationNode() { return _appNode; }

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

        uint32_t getCurrentFrame()  const { return _currentFrame; }

        uint32_t getFinishedFrame() const { return _finishedFrame.get(); }

        EQ_API void getStatistics( std::vector< FrameStatistics >& stats );

        bool isRunning() const { return _running; }

        void stopRunning() { _running = false; }

        int64_t getTime() const { return _clock.getTime64(); }

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

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

        void releaseFrameLocal( const uint32_t frameNumber )
            { _unlockedFrame = frameNumber; }

        EQ_API void stopFrames();


        EQ_API void sendEvent( ConfigEvent& event );

        EQ_API const ConfigEvent* nextEvent();

        EQ_API const ConfigEvent* tryNextEvent();

        bool checkEvent() const { return !_eventQueue.isEmpty(); }

        EQ_API virtual void handleEvents();

        EQ_API virtual bool handleEvent( const ConfigEvent* event );
        
        void setupMessagePump( Pipe* pipe );

        void setupServerConnections( const char* connectionData );

    protected:
        EQ_API virtual void attach( const co::base::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:
        co::NodePtr _appNode;

        CommandQueue _eventQueue;
        
        co::Command* _lastEvent;

        co::Connections _connections;

        co::base::Lockable< std::deque< FrameStatistics >, co::base::SpinLock >
            _statistics;
        
        uint32_t _currentFrame;
        uint32_t _unlockedFrame;
        co::base::Monitor< uint32_t > _finishedFrame;

        co::base::Clock _clock;

        std::deque< int64_t > _frameTimes; 

        bool _running;

        class LatencyObject : public co::Object
        {
        public:
            LatencyObject( const ChangeType type, const uint32_t compressor,
                           const uint32_t frame )
                    : frameNumber( frame ), _changeType( type ),
                      _compressor( compressor ) {}

            const uint32_t frameNumber;

        protected:
            virtual ChangeType getChangeType() const { return _changeType; }
            virtual void getInstanceData( co::DataOStream& os ){ EQDONTCALL }
            virtual void applyInstanceData( co::DataIStream& is ){ EQDONTCALL }
            virtual uint32_t chooseCompressor() const { return _compressor; }

        private:
            const ChangeType _changeType;
            const uint32_t _compressor;
        };
        
        typedef std::vector< LatencyObject* > LatencyObjects;

       co::base::Lockable< LatencyObjects,co::base::SpinLock > _latencyObjects;

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

        friend class Node;
        void _frameStart();
        bool _needsLocalSync() const;

        void _updateStatistics( const uint32_t finishedFrame );

        void _releaseObjects();

        void _exitMessagePump();

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

#endif // EQ_CONFIG_H