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_
 
#ifdef RTI_CXX11_RVALUE_REFERENCES
#include <utility> // std::move
#endif
 
#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_);
    }
 
#if !defined(RTI_CXX11_RVALUE_REFERENCES)
    // Enables the safe-move-constructor idiom without C++11 move constructors
    struct MoveProxy {
        MoveProxy() : input_(NULL)
        {
            native_samples_.data_array = NULL;
            native_samples_.info_array = NULL;
            native_samples_.length = 0;
        }
 
        RTI_RoutingServiceInput *input_;
        RTI_RoutingServiceLoanedSamples native_samples_;
    };
 
    LoanedSamples(MoveProxy proxy) throw() // move constructor idiom
        : input_(proxy.input_),
          native_samples_(proxy.native_samples_)
    {
    }
 
    LoanedSamples& operator= (MoveProxy proxy) throw ()
    {
        // copy-and-swap idiom: copy new value, use temp's destructor to
        // clean up existing values
        LoanedSamples temp(proxy);
        temp.swap(*this);
        return *this;
    }
 
    operator MoveProxy () throw() // move-constructor idiom
    {
        MoveProxy proxy;
 
        // move data to the proxy and return *this to an 'emtpy' state
        std::swap(input_, proxy.input_);
        std::swap(native_samples_, proxy.native_samples_);
 
        return proxy;
    }
 
private:
    // Direct assignment from one LoanedSamples to another is disabled.
    // Use the move function to assign one LoanedSamples to another.
    LoanedSamples(LoanedSamples &);
    LoanedSamples & operator = (LoanedSamples &);
 
#else
 
 
    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;
    }
 
#endif // !defined(RTI_CXX11_RVALUE_REFERENCES)
 
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
{
#if defined(RTI_CXX11_RVALUE_REFERENCES)
    return std::move(ls);
#else
    return LoanedSamples<T,U>(typename LoanedSamples<T,U>::MoveProxy(ls));
#endif
}
 
 
} } }
 
#endif // RTI_ROUTING_PROCESSOR_LOANED_SAMPLES_HPP_