Monitorable.hpp

/*
 * (c) Copyright, Real-Time Innovations, 2017.
 * All rights reserved.
 *
 * No duplications, whole or partial, manual or electronic, may be made
 * without express written permission.  Any such copies, or
 * revisions thereof, must display this notice unaltered.
 * This code contains trade secrets of Real-Time Innovations, Inc.
 */
 
#ifndef RTI_SERVICE_MONITORING_MONITORABLE_HPP_
#define RTI_SERVICE_MONITORING_MONITORABLE_HPP_
 
#include "routingservice/routingservice_service_impl.h"
 
#include <dds/core/Duration.hpp>
#include <rti/core/detail/NativeConversion.hpp>
#include <rti/apputils/ServiceException.hpp>
#include <rti/apputils/log/LogConfig.hpp>
#include <rti/routing/RoutingService.hpp>
 
namespace rti { namespace routing { namespace monitoring {
 
class Monitorable {
public:         
    
    virtual void publish_status(
            const dds::core::Duration& now) 
    {
        RTIOsapiUtility_unusedParameter(now);
    }    
    
    virtual void sample_status(
            const dds::core::Duration& now) 
    {
        RTIOsapiUtility_unusedParameter(now);
    } 
    
    virtual ~Monitorable() 
    {
    }
};
 
class MonitorableWrapper : public Monitorable {
public:         
    MonitorableWrapper()
    {
    }
        
    void native(RTI_RoutingServiceMonitorable *native_monitorable)
    {
        native_monitorable_ = native_monitorable;
    }
    
    RTI_RoutingServiceMonitorable * native()
    {
        return native_monitorable_;
    }
    
    void publish_status(
            const dds::core::Duration& now) 
    {
        DDS_Duration_t native_now;
        rti::core::native_conversions::to_native(native_now, now);
        RTINtpTime ntp_now;
        DDS_Duration_to_ntp_time(&native_now, &ntp_now);
        native_monitorable_->publish_status(
                native_monitorable_->monitorable_data,
                &ntp_now);
        
    }    
    
    virtual void sample_status(
            const dds::core::Duration& now) 
    {
        DDS_Duration_t native_now;
        rti::core::native_conversions::to_native(native_now, now);
        RTINtpTime ntp_now;
        DDS_Duration_to_ntp_time(&native_now, &ntp_now);
        native_monitorable_->sample_status(
                native_monitorable_->monitorable_data,
                &ntp_now);
    } 
 
    
private:
    RTI_RoutingServiceMonitorable *native_monitorable_;
};
 
class MonitorableForwarder  {
public:
    
    typedef RTI_RoutingServiceMonitorable native;
    
    static native create(
            Monitorable *monitorable)
    {
        native native_monitorable;
        native_monitorable.publish_status = 
                publish_status;
        native_monitorable.sample_status = 
                sample_status;
        native_monitorable.monitorable_data = 
                static_cast<void*>(monitorable);
        
        return native_monitorable;        
    }
    
private:    
    static void publish_status(
            void *monitorable_data,
            const struct RTINtpTime *now)
    {
        Monitorable *monitorable = 
                static_cast<Monitorable *>(monitorable_data);        
        try {
            DDS_Duration_t native_duration = DDS_DURATION_ZERO;
            DDS_Duration_from_ntp_time(&native_duration, now);
            
            monitorable->publish_status(
                    rti::core::native_conversions::from_native(native_duration)); 
        } catch (rti::apputils::ServiceException& ex) {
            SERVICELog_fromException(ex);
        } catch (std::exception& ex) {
            SERVICELog_exception(&RTI_LOG_ANY_s, ex.what());
        } catch (...) {
            SERVICELog_exception(&RTI_LOG_UNEXPECTED_EXCEPTION);
        }
    }
    
    static void sample_status(
            void *monitorable_data,
            const struct RTINtpTime *now)
    {
        Monitorable *monitorable = 
                static_cast<Monitorable *>(monitorable_data);        
        try {
            DDS_Duration_t native_duration = DDS_DURATION_ZERO;
            DDS_Duration_from_ntp_time(&native_duration, now);
            
            monitorable->sample_status(
                    rti::core::native_conversions::from_native(native_duration));
        } catch (rti::apputils::ServiceException& ex) {
            SERVICELog_fromException(ex);
        } catch (std::exception& ex) {
            SERVICELog_exception(&RTI_LOG_ANY_s, ex.what());
        } catch (...) {
            SERVICELog_exception(&RTI_LOG_UNEXPECTED_EXCEPTION);
        }
    }
    
};
 
inline
void register_monitorable(
        rti::routing::RoutingService& router,
        rti::routing::monitoring::Monitorable *monitorable,
        const dds::core::Duration& sampling_period,
        const dds::core::Duration& publication_period)
{
    MonitorableForwarder::native forwarder =
            MonitorableForwarder::create(monitorable);
    DDS_Duration_t native_sampling;    
    rti::core::native_conversions::to_native(native_sampling, sampling_period);
    DDS_Duration_t native_publication;
    rti::core::native_conversions::to_native(native_publication, publication_period);
    if (RTI_RoutingService_register_monitorable(
            router->native(),
            &forwarder,
            &native_sampling,
            &native_publication) == -1) {
        RTI_THROW_SERVICE_EXCEPTION(
                &RTI_LOG_ANY_FAILURE_s,
                "register native monitorable");
    }
}
 
inline
void unregister_monitorable(
        rti::routing::RoutingService& router,
        rti::routing::monitoring::Monitorable *monitorable)
{
    MonitorableForwarder::native forwarder =
            MonitorableForwarder::create(monitorable);
    RTI_RoutingService_unregister_monitorable(router->native(),  &forwarder);
}
 
 
class MonitorableAccessGuard {
public:
    MonitorableAccessGuard(rti::routing::RoutingService& service) 
        : service_(service),
         is_taken_(false)
    {        
        RTI_RoutingService_begin_monitorable_access(service_->native());
        is_taken_ = true;
    }
    
    ~MonitorableAccessGuard()
    {        
        end();
    }
    
    void end()
    {
        if (is_taken_) {
            RTI_RoutingService_end_monitorable_access(service_->native());
            is_taken_ = false;
        }
    }
    
private:
    rti::routing::RoutingService& service_;
    bool is_taken_;
};
 
 
}}}
 
 
#endif // RTI_SERVICE_MONITORING_MONITORABLE_HPP_