icestormelement.h

/*
 * Orca-Robotics Project: Components for robotics 
 *               http://orca-robotics.sf.net/
 * Copyright (c) 2004-2009 Alex Brooks, Alexei Makarenko, Tobias Kaupp
 *
 * This copy of Orca is licensed to you under the terms described in
 * the LICENSE file included in this distribution.
 *
 */

#ifndef ORCAGUI_ICESTORM_ELEMENT_H
#define ORCAGUI_ICESTORM_ELEMENT_H

#include <assert.h>
#include <orcaqguielementutil/icestormlistener.h>

namespace orcaqguielementutil {

template<class DataType, class ProxyType, class ConsumerType, class ConsumerPrxType>
class IceStormElement
{
  
public:

    IceStormElement( const orcaice::Context                     &context,
                     const std::string                          &proxyString,
                     const double                                timeoutMs,
                     const double                                tryConnectIntervalSec = 2.5 )
        : context_(context),
          listener_(context,proxyString),
          tryConnectTimer_(IceUtil::Time::seconds(999)),
          tryConnectIntervalSec_(tryConnectIntervalSec),
          timeoutMs_(timeoutMs),
          isConnected_(false),
          shouldClearPainter_(false)
    {};

    virtual ~IceStormElement() {}

    virtual void iceStormConnectedEvent() {};

protected:

    bool updateFromStore();

    orcaice::Context context_;
    
    // alexm: this is a copy of the data in Store of the listener_
    // this duplicates data storage requirements
    DataType data_;
    
    bool needToUpdate();
    
    orcaqguielementutil::IceStormListener<DataType,
                                          ProxyType,
                                          ConsumerType,
                                          ConsumerPrxType> listener_;

    gbxiceutilacfr::Timer tryConnectTimer_;
    double tryConnectIntervalSec_;
    
    double timeoutMs_;
    bool isConnected_;
    bool shouldClearPainter_;
};

template<class DataType, class ProxyType, class ConsumerType, class ConsumerPrxType>
bool 
IceStormElement<DataType,ProxyType,ConsumerType,ConsumerPrxType>::needToUpdate()
{
    if ( !isConnected_ )
    {
        if ( tryConnectTimer_.elapsedSec() < tryConnectIntervalSec_ )
            return false;
        tryConnectTimer_.restart();

        if ( listener_.connect() == 0 )
        {
            isConnected_ = true;
            assert( listener_.proxy() != 0 );
            iceStormConnectedEvent();
        }
        return false;
    }

    if ( listener_.store().isNewData() )
    {
        // An object has arrived in our buffer.  We need to update.
        return true;
    }

    // The store has nothing new.  How long since we last received something?
    if ( timeoutMs_ != -1 && listener_.msSinceReceipt() >= timeoutMs_ )
    {
        std::cout<<"TRACE(icestormelement.h): Haven't received anything from " 
                 << listener_.interfaceName() << " for " << listener_.msSinceReceipt() << "ms" << std::endl;
        std::cout<<"TRACE(icestormelement.h): Timing out..." << std::endl;

        shouldClearPainter_ = true;
        listener_.resetTimer();
        if ( listener_.connect() == 0 )
            iceStormConnectedEvent();
        else
            isConnected_ = false;
    }
    return false;
}

template<class DataType, class ProxyType, class ConsumerType, class ConsumerPrxType>
bool 
IceStormElement<DataType,ProxyType,ConsumerType,ConsumerPrxType>::updateFromStore()
{
    if ( !needToUpdate() )
        return false;
    
    assert( listener_.store().isNewData() );

    // get data from the buffer
    listener_.store().get( data_ );
    
    return true;
}

} // namespace

#endif