providerImpl.h

/*
 * Orca-Robotics Project: Components for robotics 
 *               http://orca-robotics.sf.net/
 * Copyright (c) 2004-2008 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 ORCA_PROVIDER_IMPL_H
#define ORCA_PROVIDER_IMPL_H

#include <memory>
#include <gbxsickacfr/gbxiceutilacfr/store.h>
#include <orcaice/context.h>
#include <orcaice/topichandler.h>
#include <orcaice/configutils.h>
#include <orcaice/convertutils.h>
#include <orcaice/iceutils.h>

namespace gbxiceutilacfr { class Thread; }

namespace orcaifaceimpl {

template<class ProviderType, class ProviderPrxType, class ConsumerType, class ConsumerPrxType, class DataType>
class ProviderImpl : public IceUtil::Shared
{
friend class ProviderTypeI;

public:
    ProviderImpl( const std::string& interfaceTag, const orcaice::Context& context ) :
        interfaceName_(orcaice::getProvidedInterface(context,interfaceTag).iface),
        context_(context)
    {
        init();
    }

    ProviderImpl( const orcaice::Context& context, const std::string& interfaceName ) :
        interfaceName_(interfaceName),
        context_(context)
    {
        init();
    }           

    ~ProviderImpl()
    {
        orcaice::tryRemoveInterface( context_, interfaceName_ );
    }

    // local interface:
    void initInterface()
    {
        orcaice::createInterfaceWithString( context_, ptr_, interfaceName_ );
    
        topicHandler_->connectToTopic();
    }

    void initInterface( gbxiceutilacfr::Thread* thread, const std::string& subsysName="", int retryInterval=2 )
    {
        orcaice::createInterfaceWithString( context_, ptr_, interfaceName_, thread, subsysName, retryInterval );
    
        topicHandler_->connectToTopic( thread, subsysName, retryInterval );
    }

    void localSet( const DataType& data )
    {
        dataStore_.set( data );
    }

    void localSetAndSend( const DataType& data )
    {
        dataStore_.set( data );
    
        topicHandler_->publish( data );
    }

private:    
    //
    // This is the implementation of the slice-defined interface
    //
    class ProviderTypeI : public ProviderType
    {
    public:
        ProviderTypeI( ProviderImpl &impl )
            : impl_(impl) {}
        DataType getData(const Ice::Current&)
            { return impl_.internalGetData(); }
        virtual IceStorm::TopicPrx subscribe(const ConsumerPrxType& subscriber, const ::Ice::Current& = ::Ice::Current())
            { return impl_.internalSubscribe(subscriber); }
    private:
        ProviderImpl &impl_;
    };

    // Holds the current data
    gbxiceutilacfr::Store<DataType> dataStore_;

    typedef orcaice::TopicHandler<ConsumerPrxType,DataType> TopicHandlerType;
    std::auto_ptr<TopicHandlerType> topicHandler_;

    Ice::ObjectPtr ptr_;
    const std::string interfaceName_;
    orcaice::Context context_;

    void init()
    {
        ptr_ = new ProviderTypeI( *this );

        topicHandler_.reset( new TopicHandlerType( orcaice::toTopicAsString(context_.name(),interfaceName_), context_ ) );    
    }

    // remote call implementations, mimic (but do not inherit) the orca interface
    DataType internalGetData() const
    {
        context_.tracer().debug( "ProviderImpl::internalGetData()", 5 );
    
        if ( dataStore_.isEmpty() )
        {
            std::stringstream ss;
            ss << "No data available! (interface="<<interfaceName_<<")";
            throw orca::DataNotExistException( ss.str() );
        }
    
        DataType data;
        dataStore_.get( data );
        return data;
    }

    IceStorm::TopicPrx internalSubscribe(const ConsumerPrxType& subscriber)
    {
        if ( !topicHandler_.get() ) 
        {
            throw orca::SubscriptionFailedException("Component does not have a topic to publish its traces.");
        }
        
        // if we have data, send all the information we have to the new subscriber (and to no one else)
        if ( dataStore_.isEmpty() )
        {
            return topicHandler_->subscribe( subscriber );
        }
        else
        {
            DataType data;
            dataStore_.get( data );
        
            return topicHandler_->subscribe( subscriber, data );
        }
    }
};

}

#endif