nds_buffer.hh

/* -*- mode: C++ ; c-basic-offset: 2; indent-tabs-mode: nil -*- */
 
#ifndef SWIG__COMMON__NDS_BUFFER_HH
#define SWIG__COMMON__NDS_BUFFER_HH
 
#include <cmath>
#include <iostream>
 
#include <vector>
 
#include "nds_export.hh"
#include "nds_channel.hh"
 
namespace NDS
{
 
    inline namespace abi_0
    {
        //---------------------------------------------------------------------
        //---------------------------------------------------------------------
        class buffer : public channel
        {
        public:
            //-------------------------------------------------------------------
            //-------------------------------------------------------------------
            typedef long gps_second_type;
            //-------------------------------------------------------------------
            //-------------------------------------------------------------------
            typedef long gps_nanosecond_type;
            //-------------------------------------------------------------------
            //-------------------------------------------------------------------
            typedef size_t size_type;
            //-------------------------------------------------------------------
            //-------------------------------------------------------------------
            typedef std::vector< unsigned char > data_type;
 
            static const gps_second_type GPS_INF = 1999999999;
 
            //-------------------------------------------------------------------
            //-------------------------------------------------------------------
            DLL_EXPORT
            buffer( );
 
            //-------------------------------------------------------------------
            //-------------------------------------------------------------------
            DLL_EXPORT
            buffer( const channel&      ChannelInfo,
                    gps_second_type     Second,
                    gps_nanosecond_type NanoSecond,
                    const void*         Buffer,
                    size_type           BufferSize );
 
            //-------------------------------------------------------------------
            //-------------------------------------------------------------------
            DLL_EXPORT
            buffer( const channel&      ChannelInfo,
                    gps_second_type     Second,
                    gps_nanosecond_type NanoSecond,
                    data_type&&         Buffer );
 
            //-------------------------------------------------------------------
            //-------------------------------------------------------------------
            DLL_EXPORT size_type Samples( ) const;
 
            //-------------------------------------------------------------------
            //-------------------------------------------------------------------
            DLL_EXPORT gps_second_type Start( ) const;
 
            //-------------------------------------------------------------------
            //-------------------------------------------------------------------
            DLL_EXPORT gps_nanosecond_type StartNano( ) const;
 
            //-------------------------------------------------------------------
            //-------------------------------------------------------------------
            DLL_EXPORT gps_second_type Stop( ) const;
 
            //-------------------------------------------------------------------
            //-------------------------------------------------------------------
            DLL_EXPORT gps_nanosecond_type StopNano( ) const;
            //-------------------------------------------------------------------
            //-------------------------------------------------------------------
            DLL_EXPORT void swap( buffer& Source );
 
            //-------------------------------------------------------------------
            //-------------------------------------------------------------------
            DLL_EXPORT void resize( size_type N );
 
            //-------------------------------------------------------------------
            template < typename T >
            const T*
            cbegin( ) const
            {
                const auto val_type =
                    NDS::channel_data_type_conversion< T >::value;
 
                if ( val_type == DataType( ) ||
                     ( std::is_same< T, void >::value &&
                       val_type == NDS::channel::DATA_TYPE_UNKNOWN ) )
                {
                    return reinterpret_cast< const T* >( data.data( ) );
                }
                throw std::runtime_error(
                    "Invalid cast, the buffer data type is "
                    "not compatible with your requested "
                    "type" );
            }
 
            //-------------------------------------------------------------------
            template < typename T >
            const T*
            cend( ) const
            {
                const auto val_type =
                    NDS::channel_data_type_conversion< T >::value;
 
                if ( val_type == DataType( ) ||
                     ( std::is_same< T, void >::value &&
                       val_type == NDS::channel::DATA_TYPE_UNKNOWN ) )
                {
                    return reinterpret_cast< const T* >(
                        data.data( ) + ( Samples( ) * DataTypeSize( ) ) );
                }
                throw std::runtime_error(
                    "Invalid cast, the buffer data type is "
                    "not compatible with your requested "
                    "type" );
            }
 
            //-------------------------------------------------------------------
            template < typename T >
            const T&
            at( size_type index ) const
            {
                const T* start = cbegin< T >( );
                if ( array_out_of_range( index, Samples( ) ) )
                {
                    throw std::out_of_range(
                        "The requested index is out of range" );
                }
                return start[ index ];
            }
 
            // Helper functions
 
            //-------------------------------------------------------------------
            //-------------------------------------------------------------------
            DLL_EXPORT gps_second_type
            samples_to_seconds( size_type offset_samples ) const;
 
            //-------------------------------------------------------------------
            //-------------------------------------------------------------------
            DLL_EXPORT gps_second_type
            samples_to_trailing_nanoseconds( size_type offset_samples ) const;
 
            //-------------------------------------------------------------------
            //      this byte location refers to.
            //-------------------------------------------------------------------
            DLL_EXPORT size_type
            bytes_to_samples( size_type offset_bytes ) const;
 
            //-------------------------------------------------------------------
            //      this time location refers to.
            //-------------------------------------------------------------------
            DLL_EXPORT size_type
            seconds_to_samples( gps_second_type     offset_seconds,
                                gps_nanosecond_type offset_nano = 0 ) const;
 
            //-------------------------------------------------------------------
            //-------------------------------------------------------------------
            DLL_EXPORT size_type
            samples_to_bytes( size_type offset_samples ) const;
 
            //-------------------------------------------------------------------
            //-------------------------------------------------------------------
            DLL_EXPORT void
            reset_channel_info( const channel&      ChannelInfo,
                                gps_second_type     Second,
                                gps_nanosecond_type NanoSecond );
 
        private:
            gps_second_type     gps_second;
            gps_nanosecond_type gps_nanosecond;
            data_type           data;
 
            template < typename IndexType >
            bool array_out_of_range( IndexType Index, IndexType Max ) const;
 
        protected:
            bool is_minute_trend( ) const;
        };
 
        typedef std::vector< buffer > buffers_type;
 
        inline bool
        buffer::is_minute_trend( ) const
        {
            return Type( ) == CHANNEL_TYPE_MTREND;
        }
 
        //---------------------------------------------------------------------
        //---------------------------------------------------------------------
        inline buffer::gps_second_type
        buffer::samples_to_seconds( buffer::size_type offset_samples ) const
        {
            if ( is_minute_trend( ) )
            {
                return static_cast< gps_second_type >( offset_samples * 60 );
            }
            return static_cast< gps_second_type >( offset_samples /
                                                   SampleRate( ) );
        }
 
        //---------------------------------------------------------------------
        //---------------------------------------------------------------------
        inline buffer::gps_nanosecond_type
        buffer::samples_to_trailing_nanoseconds(
            NDS::buffer::size_type offset_samples ) const
        {
            if ( is_minute_trend( ) )
            {
                return 0;
            }
            gps_nanosecond_type samples = offset_samples %
                static_cast< gps_nanosecond_type >( SampleRate( ) );
            return static_cast< gps_nanosecond_type >( 1e+9 * samples /
                                                       SampleRate( ) );
        }
 
        //---------------------------------------------------------------------
        //---------------------------------------------------------------------
        inline buffer::size_type
        buffer::bytes_to_samples( buffer::size_type offset_bytes ) const
        {
            return offset_bytes / DataTypeSize( );
        }
 
        //---------------------------------------------------------------------
        //---------------------------------------------------------------------
        inline buffer::size_type
        buffer::seconds_to_samples(
            buffer::gps_second_type     offset_seconds,
            buffer::gps_nanosecond_type offset_nano ) const
        {
            if ( is_minute_trend( ) )
            {
                return static_cast< size_type >( offset_seconds / 60 );
            }
            return static_cast< size_type >( offset_seconds * SampleRate( ) );
        }
 
        //---------------------------------------------------------------------
        //---------------------------------------------------------------------
        inline buffer::size_type
        buffer::samples_to_bytes( buffer::size_type offset_samples ) const
        {
            return offset_samples * DataTypeSize( );
        }
 
        //---------------------------------------------------------------------
        //---------------------------------------------------------------------
        inline buffer::size_type
        buffer::Samples( ) const
        {
            return data.size( ) / DataTypeSize( );
        }
 
        //---------------------------------------------------------------------
        //---------------------------------------------------------------------
        inline buffer::gps_second_type
        buffer::Start( ) const
        {
            return gps_second;
        }
 
        //---------------------------------------------------------------------
        //---------------------------------------------------------------------
        inline buffer::gps_nanosecond_type
        buffer::StartNano( ) const
        {
            return gps_nanosecond;
        }
 
        //---------------------------------------------------------------------
        //---------------------------------------------------------------------
        inline buffer::gps_second_type
        buffer::Stop( ) const
        {
            auto samples = Samples( );
            auto total_ns =
                StartNano( ) + samples_to_trailing_nanoseconds( samples );
            gps_second_type additional_from_nano =
                ( total_ns >= static_cast< gps_nanosecond_type >( 1e+9 ) ? 1
                                                                         : 0 );
            return gps_second + samples_to_seconds( samples ) +
                additional_from_nano;
        }
 
        inline buffer::gps_nanosecond_type
        buffer::StopNano( ) const
        {
            auto samples = Samples( );
            auto total_ns =
                StartNano( ) + samples_to_trailing_nanoseconds( samples );
            return total_ns % 1000000000;
        }
 
        //---------------------------------------------------------------------
        //---------------------------------------------------------------------
        inline void
        buffer::resize( size_type N )
        {
            data.resize( N * DataTypeSize( ) );
        }
 
        //---------------------------------------------------------------------
        //---------------------------------------------------------------------
 
        DLL_EXPORT extern std::ostream& operator<<( std::ostream& os,
                                                    const buffer& obj );
 
        DLL_EXPORT extern std::ostream& operator<<( std::ostream&       os,
                                                    const buffers_type& obj );
 
        //---------------------------------------------------------------------
        //---------------------------------------------------------------------
 
        template <>
        inline bool
        buffer::array_out_of_range< size_t >( size_t Index, size_t Max ) const
        {
            return ( Index >= Samples( ) );
        }
 
        template < typename IndexType >
        inline bool
        buffer::array_out_of_range( IndexType Index, IndexType Max ) const
        {
            return ( Index <= 0 || Index >= Samples( ) );
        }
 
    } // namespace abi_0
} // namespace NDS
 
#endif /* SWIG__COMMON__NDS_BUFFERL_HH */