nds_channel.hh

/* -*- mode: C++ ; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/* set vi: ts=2:softtabstop=2,shiftwidth=2,expandtab */
 
#ifndef SWIG__COMMON__NDS_CHANNEL_HH
#define SWIG__COMMON__NDS_CHANNEL_HH
 
#include <ctime>
 
#include <complex>
#include <memory>
#include <string>
#include <ostream>
#include <vector>
 
#include "nds_export.hh"
 
namespace NDS
{
    namespace detail
    {
        struct conn_p_type;
    }
 
    inline namespace abi_0
    {
        class channel
        {
        public:
            typedef enum {
                CHANNEL_TYPE_UNKNOWN = 0, 
                CHANNEL_TYPE_ONLINE = ( 1 << 0 ), 
                CHANNEL_TYPE_RAW = ( 1 << 1 ), 
                CHANNEL_TYPE_RDS = ( 1 << 2 ), 
                CHANNEL_TYPE_STREND = ( 1 << 3 ), 
                CHANNEL_TYPE_MTREND = ( 1 << 4 ), 
                CHANNEL_TYPE_TEST_POINT = ( 1 << 5 ), 
                CHANNEL_TYPE_STATIC = ( 1 << 6 ) 
            } channel_type;
 
            typedef enum {
                DATA_TYPE_UNKNOWN = 0, 
                DATA_TYPE_INT16 = ( 1 << 0 ), 
                DATA_TYPE_INT32 = ( 1 << 1 ), 
                DATA_TYPE_INT64 = ( 1 << 2 ), 
                DATA_TYPE_FLOAT32 = ( 1 << 3 ), 
                DATA_TYPE_FLOAT64 = ( 1 << 4 ), 
                DATA_TYPE_COMPLEX32 =
                    ( 1 << 5 ), 
                DATA_TYPE_UINT32 = ( 1 << 6 ) 
            } data_type;
 
            class hash_type : private std::vector< unsigned char >
            {
            public:
                typedef std::vector< unsigned char > element_type;
 
                using element_type::size;
 
                hash_type( );
 
                bool compare( const void* Buffer,
                              size_t      Length = ( size_t )( -1 ) ) const;
 
                const void* ref( ) const;
 
                void reset( );
 
            private:
                friend struct NDS::detail::conn_p_type;
 
                static const unsigned char zero_hash[ 1 ];
                static const size_t        MAX_SIZE;
            };
 
            typedef double sample_rate_type; 
            typedef float  signal_gain_type; 
            typedef float  signal_slope_type; 
            typedef float  signal_offset_type; 
            typedef size_t
                size_type; 
 
            typedef std::vector< std::string > channel_names_type;
 
            DLL_EXPORT static const channel_type DEFAULT_CHANNEL_MASK =
                ( channel_type )(
                    CHANNEL_TYPE_ONLINE | CHANNEL_TYPE_RAW | CHANNEL_TYPE_RDS |
                    CHANNEL_TYPE_STREND | CHANNEL_TYPE_MTREND |
                    CHANNEL_TYPE_TEST_POINT | CHANNEL_TYPE_STATIC );
 
            DLL_EXPORT static const data_type DEFAULT_DATA_MASK = ( data_type )(
                DATA_TYPE_INT16 | DATA_TYPE_INT32 | DATA_TYPE_INT64 |
                DATA_TYPE_FLOAT32 | DATA_TYPE_FLOAT64 | DATA_TYPE_COMPLEX32 |
                DATA_TYPE_UINT32 );
 
            DLL_EXPORT static const sample_rate_type
                MIN_SAMPLE_RATE; 
            DLL_EXPORT static const sample_rate_type
                MAX_SAMPLE_RATE; 
 
            DLL_EXPORT static channel_type convert_daq_chantype( int ChanType );
 
            DLL_EXPORT static data_type convert_daq_datatype( int DataType );
 
            DLL_EXPORT static const std::string&
            ToString( channel_type ChannelType );
 
            DLL_EXPORT static const std::string& ToString( data_type DataType );
 
            DLL_EXPORT
            channel( );
 
            DLL_EXPORT
            channel( const channel& Source );
 
            DLL_EXPORT
            channel( const std::string& Name,
                     channel_type       Type,
                     data_type          DataType,
                     sample_rate_type   SampleRate,
                     signal_gain_type   Gain,
                     signal_slope_type  Slope,
                     signal_offset_type Offset,
                     std::string        Units );
 
            DLL_EXPORT const std::string& Name( ) const;
 
            DLL_EXPORT std::string NameLong( ) const;
 
            DLL_EXPORT channel_type Type( ) const;
 
            DLL_EXPORT data_type DataType( ) const;
 
            DLL_EXPORT size_type DataTypeSize( ) const;
 
            DLL_EXPORT sample_rate_type SampleRate( ) const;
 
            DLL_EXPORT signal_gain_type Gain( ) const;
 
            DLL_EXPORT signal_slope_type Slope( ) const;
 
            DLL_EXPORT signal_offset_type Offset( ) const;
 
            DLL_EXPORT const std::string& Units( ) const;
 
            DLL_EXPORT void swap( channel& Source );
 
            DLL_EXPORT static bool IsSecondTrend( const std::string& Name );
 
            DLL_EXPORT static bool IsMinuteTrend( const std::string& Name );
 
        private:
            std::string        name;
            channel_type       type;
            data_type          data;
            sample_rate_type   sample_rate;
            signal_gain_type   gain;
            signal_slope_type  slope;
            signal_offset_type offset;
            std::string        units;
        };
 
        typedef std::vector< channel > channels_type;
 
        inline const void*
        channel::hash_type::ref( ) const
        {
            return ( ( size( ) > 0 ) ? &( this->operator[]( 0 ) ) : zero_hash );
        }
 
        inline const std::string&
        channel::Name( ) const
        {
            return name;
        }
 
        inline channel::channel_type
        channel::Type( ) const
        {
            return type;
        }
 
        inline channel::data_type
        channel::DataType( ) const
        {
            return data;
        }
 
        inline channel::size_type
        channel::DataTypeSize( ) const
        {
            switch ( data )
            {
            case DATA_TYPE_INT16:
                return ( 2 );
                break;
            case DATA_TYPE_INT32:
            case DATA_TYPE_FLOAT32:
            case DATA_TYPE_UINT32:
                return ( 4 );
                break;
            case DATA_TYPE_INT64:
            case DATA_TYPE_FLOAT64:
            case DATA_TYPE_COMPLEX32:
                return ( 8 );
                break;
            default:
                return 0;
            }
        }
 
        inline channel::sample_rate_type
        channel::SampleRate( ) const
        {
            return sample_rate;
        }
 
        inline channel::signal_gain_type
        channel::Gain( ) const
        {
            return gain;
        }
 
        inline channel::signal_slope_type
        channel::Slope( ) const
        {
            return slope;
        }
 
        inline channel::signal_offset_type
        channel::Offset( ) const
        {
            return offset;
        }
 
        inline const std::string&
        channel::Units( ) const
        {
            return units;
        }
 
        inline bool
        channel::IsSecondTrend( const std::string& Name )
        {
            static const std::string STREND_EXT( ",s-trend" );
 
            if ( Name.size( ) <= STREND_EXT.size( ) )
            {
                return false;
            }
            return ( STREND_EXT.compare( Name.substr(
                         Name.size( ) - STREND_EXT.size( ) ) ) == 0 );
        }
 
        inline bool
        channel::IsMinuteTrend( const std::string& Name )
        {
            static const std::string MTREND_EXT( ",m-trend" );
 
            if ( Name.size( ) <= MTREND_EXT.size( ) )
            {
                return false;
            }
            return ( MTREND_EXT.compare( Name.substr(
                         Name.size( ) - MTREND_EXT.size( ) ) ) == 0 );
        }
 
        DLL_EXPORT extern std::ostream& operator<<( std::ostream&  os,
                                                    const channel& ch );
 
        template < typename T >
        struct channel_data_type_conversion
        {
            static const NDS::channel::data_type value =
                NDS::channel::DATA_TYPE_UNKNOWN;
        };
 
        template <>
        struct channel_data_type_conversion< std::int16_t >
        {
            static const NDS::channel::data_type value =
                NDS::channel::DATA_TYPE_INT16;
        };
 
        template <>
        struct channel_data_type_conversion< std::int32_t >
        {
            static const NDS::channel::data_type value =
                NDS::channel::DATA_TYPE_INT32;
        };
 
        template <>
        struct channel_data_type_conversion< std::int64_t >
        {
            static const NDS::channel::data_type value =
                NDS::channel::DATA_TYPE_INT64;
        };
 
        template <>
        struct channel_data_type_conversion< float >
        {
            static const NDS::channel::data_type value =
                ( NDS::channel::DATA_TYPE_FLOAT32 );
        };
 
        template <>
        struct channel_data_type_conversion< double >
        {
            static const NDS::channel::data_type value =
                NDS::channel::DATA_TYPE_FLOAT64;
        };
 
        template <>
        struct channel_data_type_conversion< std::complex< float > >
        {
            static const NDS::channel::data_type value =
                ( NDS::channel::DATA_TYPE_COMPLEX32 );
        };
 
        template <>
        struct channel_data_type_conversion< std::uint32_t >
        {
            static const NDS::channel::data_type value =
                NDS::channel::DATA_TYPE_UINT32;
        };
 
        DLL_EXPORT const std::string&
        channel_type_to_string( channel::channel_type ctype );
 
        DLL_EXPORT const std::string&
        data_type_to_string( channel::data_type dtype );
    }
} // namespace - NDS
 
#endif /* SWIG__COMMON__NDS_CHANNEL_HH */