LoanedSamples.hpp

/* $Id$
 
(c) Copyright, Real-Time Innovations, 2013-2016.
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_ROUTING_PROCESSOR_LOANED_SAMPLES_HPP_
#define RTI_ROUTING_PROCESSOR_LOANED_SAMPLES_HPP_
 
#include <utility>  // std::move
#include <iterator>
 
#include "routingservice/routingservice_adapter_new.h"
#include <dds/core/types.hpp>
#include <rti/routing/processor/LoanedSample.hpp>
#include <rti/routing/adapter/StreamReader.hpp>
#include <rti/routing/processor/SampleIterator.hpp>
 
namespace rti { namespace routing { namespace processor {
 
template <typename T, typename U> class TypedInput;
 
 
template <typename T, typename U = dds::sub::SampleInfo>
class LoanedSamples {
public:
 
    typedef rti::routing::adapter::StreamReader StreamReader;
    typedef typename std::vector<StreamReader::SamplePtr> SampleSeqType;
    typedef typename std::vector<StreamReader::InfoPtr> InfoSeqType;
 
    typedef SampleIterator<T, U> iterator;
    typedef SampleIterator<T, U> const_iterator;
    typedef typename SampleIterator<T, U>::value_type value_type;
    typedef std::ptrdiff_t difference_type;
 
    LoanedSamples() : input_(NULL)
    {
        native_samples_.data_array = NULL;
        native_samples_.info_array = NULL;
        native_samples_.length = 0;
 
    }
 
public:
    // Private c-tor only to be used by static method create_from_loans()
    LoanedSamples(
            RTI_RoutingServiceInput *native_input,
            RTI_RoutingServiceLoanedSamples& native_samples)
        : input_(native_input),
          native_samples_(native_samples)
    {
    }
 
public:
 
    ~LoanedSamples() throw()
    {
        try {
            return_loan();
        } catch (const std::exception&) { // Do not throw in destructor
 
        }
    }
 
 
    LoanedSample<T,U> operator [] (size_t index)
    {
        return native_samples_.info_array == NULL
                ? LoanedSample<T, U>(native_samples_.data_array[index], NULL)
                : LoanedSample<T, U>(
                        native_samples_.data_array[index],
                        native_samples_.info_array[index]);
    }
 
    int32_t length() const
    {
        return native_samples_.length;
    }
 
    void return_loan()
    {
        if (input_) {
            if (!RTI_RoutingServiceInput_return_loan(
                    input_,
                    &native_samples_)) {
                throw dds::core::Error("error returning loaned samples to native input");
            }
            input_ = NULL; // Indicate that this object doesn't hold a loan anymore
        }
    }
    
        
    bool has_infos()
    {
        return (native_samples_.info_array != NULL);
    }
 
 
    iterator begin()
    {
        return iterator(
                native_samples_.data_array,
                native_samples_.info_array,
                native_samples_.length);
    }
 
    iterator end()
    {
        return iterator(
                native_samples_.data_array,
                native_samples_.info_array,
                native_samples_.length,
                native_samples_.length);
    }
 
    const_iterator begin() const
    {
        return const_iterator(
                native_samples_.data_array,
                native_samples_.info_array,
                native_samples_.length);
    }
 
    const_iterator end() const
    {
        return const_iterator(
                native_samples_.data_array,
                native_samples_.info_array,
                native_samples_.length,
                native_samples_.length);
    }
 
    void swap(LoanedSamples& other) throw()
    {
        std::swap(input_, other.input_);
        std::swap(native_samples_, other.native_samples_);
    }
 
    LoanedSamples(LoanedSamples&& other)
        :input_(NULL)
    {
        native_samples_.data_array = NULL;
        native_samples_.info_array = NULL;
        native_samples_.length = 0;
        other.swap(*this);
    }
 
 
    LoanedSamples& operator= (LoanedSamples&& other) throw ()
    {
        // clean up existing values
        LoanedSamples temp(std::move(other));
        temp.swap(*this);
        return *this;
    }
 
private:
   friend class TypedInput<T, U>;
 
    void release()
    {
        input_ = NULL;
    }
 
    RTI_RoutingServiceLoanedSamples& native_samples()
    {
        return native_samples_;
    }
 
private:
    // reference to the reader that created this LoanedSamples object
    RTI_RoutingServiceInput *input_;
    RTI_RoutingServiceLoanedSamples native_samples_;
 
};
 
template <typename T, typename U>
LoanedSamples<T, U> move(LoanedSamples<T,U> & ls) OMG_NOEXCEPT
{
    return std::move(ls);
}
 
 
} } }
 
#endif // RTI_ROUTING_PROCESSOR_LOANED_SAMPLES_HPP_