reference_clock_intf.h

Go to the documentation of this file.

#pragma once
 
#include <adtfucom3/adtf_ucom3.h>
#include <adtfbase/chrono.h>
#include <adtfbase/string_intf.h>
#include <adtf_base_deprecated.h>

#define CID_ADTF_REFERENCE_CLOCK "reference_clock.service.adtf.cid"
 
namespace adtf
{
namespace services
{
namespace ant
{

class IReferenceClock : public adtf::ucom::ant::IObject
{
    protected:
        ~IReferenceClock() = default;
    public:

        ADTF_IID(IReferenceClock, "reference_clock.ant.streaming.adtf.iid");
 
    public:

        static const int ADTF_MAX_CLOCK_NAME_LENGTH = 256;
 
    public:

        enum tReferenceClockEventId
        {
            EVENT_TimeResetBegin        = 0x0000,
            EVENT_TimeResetEnd          = 0x0001,
            EVENT_TimeUpdate            = 0x0004
        };

        struct tReferenceClockEvent
        {
            tHandle             hObject;
            int                nEventId;
            tTimeStamp          nOldTime;
            tTimeStamp          nNewTime;
        };

        class IClock: public ucom::IObject
        {
            public:
                ADTF_IID(IClock, "clock.reference_clock.ant.streaming.adtf.iid");
 
            public:
                virtual tResult GetName(adtf::base::ant::IString&& strName) const = 0;

                virtual tTimeStamp GetTime() const = 0;
        };

        class IClockListCallback
        {
            public:
                virtual tResult HandleClock(const ucom::ant::iobject_ptr<IClock>& pClock) = 0;
        };

        class ISync2RefChannel: public ucom::IObject
        {
            public:
                ADTF_IID(ISync2RefChannel, "sync2ref_channel.reference_clock.ant.streaming.adtf.iid");
 
            public:
                virtual tTimeStamp Sync2RefTime(tTimeStamp tmInputTime) = 0;
                virtual tTimeStamp Sync2RefTime(tTimeStamp tmRefStreamTime, tTimeStamp tmInputTime) = 0;
        };

        class ISync2RefChannelFactory : public ucom::IObject
        {
            public:
                ADTF_IID(ISync2RefChannelFactory, "sync2ref_channel_factory.reference_clock.ant.streaming.adtf.iid");
 
            public:
                virtual tResult GetName(adtf::base::ant::IString&& strName) const = 0;
                virtual tResult GetSync2RefChannel(adtf::ucom::ant::iobject_ptr<ISync2RefChannel>& pSync2RefChannel, const char* strName = nullptr) = 0;
        };

        class ISync2RefListCallback
        {
            public:
                virtual tResult HandleSync2RefFactory(ISync2RefChannelFactory& oFactory) = 0;
        };
 
 
    public:
        virtual tTimeStamp GetTime() const = 0;

        virtual tTimeStamp GetStreamTime() const = 0;

        virtual tResult RegisterClock(const adtf::ucom::ant::iobject_ptr<IClock>& pClock) = 0;

        virtual tResult UnregisterClock(const adtf::ucom::ant::iobject_ptr<IClock>& pClock) = 0;

        virtual tResult GetClocks(IClockListCallback& oCallback) const = 0;

        virtual tResult GetClock(const char* strName, adtf::ucom::ant::iobject_ptr<IClock>& pClock) const = 0;

        virtual tResult SetMainClock(const char* strName) = 0;

        virtual tResult GetMainClock(adtf::base::ant::IString&& strName) const = 0;

        virtual tResult SetStreamClock(const char* strName) = 0;

        virtual tResult GetStreamClock(adtf::base::ant::IString&& strName) const = 0;

        virtual tResult RegisterSync2RefFactory(const adtf::ucom::ant::iobject_ptr<ISync2RefChannelFactory>& oSync2RefFactory) = 0;

        virtual tResult UnregisterSync2RefFactory(const adtf::ucom::ant::iobject_ptr<ISync2RefChannelFactory>& oSync2RefFactory) = 0;

        virtual tResult ListSync2RefMethods(ISync2RefListCallback& oCallback) = 0;

        ADTF3_DEPRECATED("Use adtf::services::vision::GetSync2RefChannel(adtf::ucom::ant::iobject_ptr<adtf::services::vision::IReferenceClock::ISync2RefChannel>& pSync2RefChannel, const char* strName = nullptr, const char* strMethod = nullptr) instead.")
        virtual tResult GetSync2RefChannel(adtf::ucom::ant::iobject_ptr<ISync2RefChannel>& pSync2RefChannel,
                                           const char* strName = nullptr, const char* strMethod = nullptr) const = 0;
};
 
} //namespace ant
 
namespace flash
{

class IReferenceClock: public ant::IReferenceClock
{
    protected:
        ~IReferenceClock() = default;
 
    public:

        ADTF_IID(IReferenceClock, "reference_clock.flash.streaming.adtf.iid");
 
    public:
        struct tReferenceClockEvent: public ant::IReferenceClock::tReferenceClockEvent
        {
            adtf::base::flash::tNanoSeconds nOldTimeNs;
            adtf::base::flash::tNanoSeconds nNewTimeNs;
        };

        class IClock: public ant::IReferenceClock::IClock
        {
            public:
                ADTF_IID(IClock, "clock.reference_clock.flash.streaming.adtf.iid");
 
            public:
                virtual base::flash::tNanoSeconds GetTimeNs() const = 0;
        };

        class ISync2RefChannel: public ant::IReferenceClock::ISync2RefChannel
        {
            public:
                ADTF_IID(ISync2RefChannel, "sync2ref_channel.reference_clock.flash.streaming.adtf.iid");
 
            public:
                using ant::IReferenceClock::ISync2RefChannel::Sync2RefTime;
                virtual base::flash::tNanoSeconds Sync2RefTime(base::flash::tNanoSeconds tmInputTime) = 0;
                virtual base::flash::tNanoSeconds Sync2RefTime(base::flash::tNanoSeconds tmRefStreamTime, base::flash::tNanoSeconds tmInputTime) = 0;
        };
 
    public:
        virtual base::flash::tNanoSeconds GetTimeNs() const = 0;
        virtual base::flash::tNanoSeconds GetStreamTimeNs() const = 0;
 
        using ant::IReferenceClock::GetSync2RefChannel;

        ADTF3_DEPRECATED("Use adtf::services::vision::GetSync2RefChannel(adtf::ucom::ant::iobject_ptr<adtf::services::vision::IReferenceClock::ISync2RefChannel>& pSync2RefChannel, const char* strName = nullptr, const char* strMethod = nullptr) instead.")
        virtual tResult GetSync2RefChannel(adtf::ucom::ant::iobject_ptr<ISync2RefChannel>& pSync2RefChannel,
                                           const char* strName = nullptr, const char* strMethod = nullptr) const = 0;
};
 
} // namespace flash
 
namespace giant
{

class IReferenceClock: public flash::IReferenceClock
{
    protected:
        ~IReferenceClock() = default;
 
    public:

        ADTF_IID(IReferenceClock, "reference_clock.giant.streaming.adtf.iid");
 
    public:

        class ISync2RefChannel: public flash::IReferenceClock::ISync2RefChannel
        {
            public:
                ADTF_IID(ISync2RefChannel, "sync2ref_channel.reference_clock.giant.streaming.adtf.iid");

                virtual void SyncReset() = 0;
        };
 
    public:
        using ant::IReferenceClock::GetSync2RefChannel;
        using flash::IReferenceClock::GetSync2RefChannel;

        ADTF3_DEPRECATED("Use adtf::services::vision::GetSync2RefChannel(adtf::ucom::ant::iobject_ptr<adtf::services::vision::IReferenceClock::ISync2RefChannel>& pSync2RefChannel, const char* strName = nullptr, const char* strMethod = nullptr) instead.")
        virtual tResult GetSync2RefChannel(adtf::ucom::ant::iobject_ptr<ISync2RefChannel>& pSync2RefChannel,
                                           const char* strName = nullptr, const char* strMethod = nullptr) const = 0;
};
 
} // namespace giant
 
namespace osborn
{

class IReferenceClock: public giant::IReferenceClock
{
    protected:
        ~IReferenceClock() = default;
 
    public:

        ADTF_IID(IReferenceClock, "reference_clock.osborn.streaming.adtf.iid");

        class ISystemClock: public ucom::ant::IObject
        {
            public:
                ADTF_IID(ISystemClock, "system_clock.reference_clock.osborn.streaming.adtf.iid");

                virtual bool IsSystemClock() const = 0;
        };

        virtual tResult ConvertStreamTime(adtf::base::flash::tNanoSeconds tmStreamTime, adtf::base::ant::IString&& strStringRepresentation) const = 0;

        virtual tResult ConvertStreamTime(const char* strStringRepresentation, adtf::base::flash::tNanoSeconds& tmStreamTime) const = 0;

        virtual tResult ConvertTimeOffset(adtf::base::flash::tNanoSeconds tmOffset, adtf::base::ant::IString&& strStringRepresentation) const = 0;

        virtual tResult ConvertTimeOffset(const char* strStringRepresentation, adtf::base::flash::tNanoSeconds& tmOffset) const = 0;
 
 
        using ant::IReferenceClock::GetSync2RefChannel;
        using flash::IReferenceClock::GetSync2RefChannel;
        using giant::IReferenceClock::GetSync2RefChannel;

        ADTF3_DEPRECATED("Use adtf::services::vision::GetSync2RefChannel(bool bSystemClockTimestamps, adtf::ucom::ant::iobject_ptr<adtf::services::vision::IReferenceClock::ISync2RefChannel>& pSync2RefChannel, const char* strName) instead.")
        virtual tResult GetSync2RefChannel(bool bSystemClockTimestamps,
                                           adtf::ucom::ant::iobject_ptr<giant::IReferenceClock::ISync2RefChannel>& pSync2RefChannel,
                                           const char* strName = nullptr) const = 0;
};
 
}// namespace osborn
 
namespace penguin
{

class IReferenceClock: public osborn::IReferenceClock
{
    protected:
        ~IReferenceClock() = default;
 
    public:

        ADTF_IID(IReferenceClock, "reference_clock.penguin.streaming.adtf.iid");
 
    public:

        class ITimeBarrier: public ucom::ant::IObject
        {
            public:
                virtual tResult WaitUntilBegin() const = 0;

                enum class tTimePointId: uint8_t
                {
                    Begin = 0, 
                    End = 1 
                };

                static constexpr base::flash::tNanoSeconds NoTimePoint{-1};

                virtual base::flash::tNanoSeconds GetTimePoint(tTimePointId eTimePointId) const = 0;

                virtual bool IsBroken(tTimePointId eTimePointId) const = 0;
        };

        class ITimeGuard: public ucom::ant::IObject
        {
            public:
                ADTF_IID(ITimeGuard, "time_guard.reference_clock.penguin.streaming.adtf.iid");

                virtual tResult CreateBarrier(base::flash::tNanoSeconds tmBegin,
                                              base::flash::tNanoSeconds tmEnd,
                                              ucom::ant::iobject_ptr<ITimeBarrier>& pBarrier) = 0;

                virtual void Cancel() = 0;
        };
 

        class IGuardableClock: public ucom::ant::IObject
        {
            public:
                ADTF_IID(IGuardableClock, "guardable_clock.reference_clock.penguin.streaming.adtf.iid");
 
            public:
                virtual tResult GetTimeGuard(const char* strName, ucom::ant::iobject_ptr<ITimeGuard>& pGuard) = 0;
        };

        virtual tResult GetTimeGuard(const char* strName, ucom::ant::iobject_ptr<ITimeGuard>& pGuard) = 0;
};
 
}// namespace penguin
 
namespace riddler
{
class IReferenceClock : public penguin::IReferenceClock
{
protected:
    ~IReferenceClock() = default;
 
public:
    ADTF_IID(IReferenceClock, "reference_clock.riddler.streaming.adtf.iid");
 
    enum class tTimeBase : uint8_t
    {
        UNSPECIFIED, 
        POSIX_UTC, 
        POSIX_TAI 
    };
 
    using ant::IReferenceClock::GetSync2RefChannel;
    using flash::IReferenceClock::GetSync2RefChannel;
    using giant::IReferenceClock::GetSync2RefChannel;
    using osborn::IReferenceClock::GetSync2RefChannel;

    ADTF3_DEPRECATED("Use adtf::services::vision::GetSync2RefChannel(tTimeBase eTimeBase, adtf::ucom::ant::iobject_ptr<adtf::services::vision::IReferenceClock::ISync2RefChannel>& pSync2RefChannel, const char* strName) instead.")
    virtual tResult GetSync2RefChannel(tTimeBase eTimeBase,
                                       adtf::ucom::ant::iobject_ptr<IReferenceClock::ISync2RefChannel>& pSync2RefChannel,
                                       const char* strName = nullptr) const = 0;
};
 
} // namespace riddler
 
namespace vision
{
 
class IReferenceClock : public riddler::IReferenceClock
{
protected:
    ~IReferenceClock() = default;
 
public:
    ADTF_IID(IReferenceClock, "reference_clock.vision.streaming.adtf.iid");
 
    using ant::IReferenceClock::GetSync2RefChannel;
    using flash::IReferenceClock::GetSync2RefChannel;
    using giant::IReferenceClock::GetSync2RefChannel;
    using osborn::IReferenceClock::GetSync2RefChannel;
    using riddler::IReferenceClock::GetSync2RefChannel;
 
    class ISync2RefChannel : public riddler::IReferenceClock::ISync2RefChannel
    {
    public:
        ADTF_IID(ISync2RefChannel, "sync2ref_channel.reference_clock.vision.streaming.adtf.iid");
 
        virtual base::flash::tNanoSeconds Sync2ExternalTime(base::flash::tNanoSeconds tmInputTime) = 0;
    };

    virtual tResult GetSync2RefChannel(adtf::ucom::ant::iobject_ptr<ISync2RefChannel>& pSync2RefChannel,
                                       const char* strName = nullptr,
                                       const char* strMethod = nullptr) const = 0;

    virtual tResult GetSync2RefChannel(bool bSystemClockTimestamps,
                                       adtf::ucom::ant::iobject_ptr<IReferenceClock::ISync2RefChannel>& pSync2RefChannel,
                                       const char* strName = nullptr) const = 0;

    virtual tResult GetSync2RefChannel(tTimeBase eTimeBase,
                                       adtf::ucom::ant::iobject_ptr<IReferenceClock::ISync2RefChannel>& pSync2RefChannel,
                                       const char* strName = nullptr) const = 0;
};
 
} // namespace vision

namespace detail
{
 
class ISimulationClock: public adtf::ucom::ant::IObject
{
    public:
        ADTF_IID(ISimulationClock, "simulation_clock.detail.streaming.adtf.iid");
 
        virtual tResult SetClockSpeed(double fSpeed) = 0;
        virtual tResult Reset(adtf::base::flash::tNanoSeconds tmTime, bool bSystemClock) = 0;
        virtual tResult Run() = 0;
        virtual tResult Pause() = 0;
        virtual bool IsRunning() const = 0;
        virtual double GetClockSpeed() const = 0;
};
 
} // namespace detail


using vision::IReferenceClock;
 
} // namespace services
 
} // namespace adtf