SelectorState.hpp

/*
 * (c) Copyright, Real-Time Innovations, 2018-.
 * 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 HPP_RTI_RECORDING_STORAGE_SAMPLESELECTOR_HPP_
#define HPP_RTI_RECORDING_STORAGE_SAMPLESELECTOR_HPP_

#include "dds/dds.hpp"
#include "rti/core/NativeValueType.hpp"
#include "rti/core/constants.hpp"

#include "recordingservice/recordingservice_storagereader.h"

namespace rti { namespace recording { namespace storage {

class SelectorState;


class SelectorStateAdapter {
public:
    typedef RTI_RecordingServiceSelectorState native_type;

    static void initialize(native_type& native_value)
    {
        RTI_RecordingServiceSelectorState native_state =
                RTI_RecordingServiceSelectorState_INITIALIZER;
        memcpy(&native_value, &native_state, sizeof(native_state));
    }

    static void finalize(native_type&)
    {
    }

    static void copy(native_type& destination, const native_type& source)
    {
        destination.sample_state = source.sample_state;
        destination.time_range_start = source.time_range_start;
        destination.time_range_end = source.time_range_end;
        destination.max_samples = source.max_samples;
        destination.instance_history = source.instance_history;
    }

    static bool equals(const native_type& first, const native_type& second)
    {
        if (first.sample_state != second.sample_state) {
            return false;
        }
        if (first.max_samples != second.max_samples) {
            return false;
        }
        if (!DDS_Time_t_equals(
                first.time_range_start,
                second.time_range_start)) {
            return false;
        }
        if (!DDS_Time_t_equals(
                first.time_range_end,
                second.time_range_end)) {
            return false;
        }
        return first.instance_history.depth == second.instance_history.depth;
    }
};

} }

/*
 * Type native_type_traits needs to be defined in the rti::core namespace.
 */
namespace core {

template <>
struct native_type_traits<rti::recording::storage::SelectorState> {
    typedef rti::recording::storage::SelectorStateAdapter adapter_type;
    typedef RTI_RecordingServiceSelectorState native_type;
};

}

namespace recording { namespace storage {

class SelectorState : public rti::core::NativeValueType<SelectorState> {
public:
    RTI_NATIVE_VALUE_TYPE_DEFINE_DEFAULT_MOVE_OPERATIONS(SelectorState)

    typedef rti::core::NativeValueType<SelectorState> Base;

    SelectorState()
    {
    }

    SelectorState(const RTI_RecordingServiceSelectorState &native) :
        Base(native)
    {
    }

    inline dds::sub::status::SampleState sample_state() const
    {
        return dds::sub::status::SampleState(native().sample_state);
    }

    SelectorState& sample_state(const dds::sub::status::SampleState& state)
    {
         native().sample_state =
                 static_cast<RTI_RecordingServiceSampleStateMask>(
                         state.to_ulong());
         return *this;
    }

    inline dds::core::Time time_range_start() const
    {
        return dds::core::Time(
                native().time_range_start.sec,
                native().time_range_start.nanosec);
    }

    inline int64_t timestamp_range_start() const
    {
        int64_t timestamp =
                (int64_t) native().time_range_start.sec
                        * rti::core::nanosec_per_sec
                + native().time_range_start.nanosec;
        return timestamp;
    }

    SelectorState& time_range_start(const dds::core::Time& time_range_start)
    {
        native().time_range_start.sec = (DDS_Long) time_range_start.sec();
        native().time_range_start.nanosec =
                (DDS_UnsignedLong) time_range_start.nanosec();
        return *this;
    }

    inline dds::core::Time time_range_end() const
    {
        return dds::core::Time(
                native().time_range_end.sec,
                native().time_range_end.nanosec);
    }

    inline int64_t timestamp_range_end() const
    {
        int64_t timestamp =
                (int64_t) native().time_range_end.sec
                        * rti::core::nanosec_per_sec
                + native().time_range_end.nanosec;
        return timestamp;
    }

    SelectorState& time_range_end(const dds::core::Time& time_range_end)
    {
        native().time_range_end.sec = (DDS_Long) time_range_end.sec();
        native().time_range_end.nanosec =
                (DDS_UnsignedLong) time_range_end.nanosec();
        return *this;
    }

    inline int32_t max_samples() const
    {
        return native().max_samples;
    }

    SelectorState& max_samples(const int32_t max_samples)
    {
        native().max_samples = (int) max_samples;
        return *this;
    }

    inline int32_t instance_history_depth() const
    {
        return native().instance_history.depth;
    }

    SelectorState& instance_history_depth(const int32_t depth)
    {
        native().instance_history.depth = (int) depth;
        return *this;
    }

};


} } } /* namespace rti::recording::storage */

#endif /* HPP_RTI_RECORDING_STORAGE_SAMPLESELECTOR_HPP_ */