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 "rti/apputils/util/Utils.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
    {
        return rti::apputils::util::convert_uint64_into_int64(
                rti::apputils::util::to_nanosecs(time_range_start()));
    }
 
    SelectorState& time_range_start(const dds::core::Time& time_range_start)
    {
        native().time_range_start.sec = 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
    {
        return rti::apputils::util::convert_uint64_into_int64(
                rti::apputils::util::to_nanosecs(time_range_end()));
    }
 
    SelectorState& time_range_end(const dds::core::Time& time_range_end)
    {
        native().time_range_end.sec = time_range_end.sec();
        native().time_range_end.nanosec =
                static_cast<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_ */