nds_connection.hh

/* -*- mode: C++ ; c-basic-offset: 2; indent-tabs-mode: nil -*- */

/*
 * High-level NDS client C++ library
 *
 * Copyright (C) 2015  Edward Maros <ed.maros@ligo.org>
 *
 * This work is derived from the C NDS clientlibrary created by Leo Singer
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef SWIG__COMMON__NDS_CONNECTION_HH
#define SWIG__COMMON__NDS_CONNECTION_HH

#include <memory>
#include <stdexcept>
#include <string>
#include <ostream>

#include "nds_export.hh"
#include "nds_buffer.hh"
#include "nds_channel.hh"
#include "nds_data_iterator.hh"
#include "nds_availability.hh"
#include "nds_epoch.hh"

namespace NDS
{
    namespace detail
    {
        struct conn_p_type;
        class parameter_block;
        class parameter_accessor;
    } // namespace detail
    inline namespace abi_0
    {
        class parameters;

        struct frequency_range
        {
            NDS::channel::sample_rate_type
                minimum; 
            NDS::channel::sample_rate_type
                maximum; 

            frequency_range( )
                : minimum( NDS::channel::MIN_SAMPLE_RATE ),
                  maximum( NDS::channel::MAX_SAMPLE_RATE )
            {
            }
            frequency_range( NDS::channel::sample_rate_type Min,
                             NDS::channel::sample_rate_type Max )
                : minimum( Min ), maximum( Max )
            {
            }
            frequency_range( const frequency_range& other ) = default;
            frequency_range&
            operator=( const frequency_range& other ) = default;
        };

        class channel_predicate_object
        {
        public:
            typedef std::vector< NDS::channel::channel_type > channel_type_list;
            typedef std::vector< NDS::channel::data_type >    data_type_list;

            channel_predicate_object( )
                : epoch_( "", 0, NDS::buffer::GPS_INF ), glob_( ),
                  channel_types_( ), data_types_( ), sample_rates_( )
            {
            }

            channel_predicate_object( const channel_predicate_object& other ) =
                default;

            channel_predicate_object( channel_predicate_object&& other ) =
                default;

            channel_predicate_object&
            operator=( const channel_predicate_object& other ) = default;

            channel_predicate_object&
            operator=( channel_predicate_object&& other ) = default;

            std::string
            glob( ) const
            {
                return ( glob_.empty( ) ? "*" : glob_ );
            }

            const channel_type_list
            channel_types( ) const
            {

                if ( channel_types_.empty( ) )
                {
                    channel_type_list result{ all_channel_types };
                    return result;
                }
                return channel_types_;
            }

            NDS::channel::channel_type
            channel_type_mask( ) const
            {
                if ( channel_types_.empty( ) )
                {
                    return NDS::channel::DEFAULT_CHANNEL_MASK;
                }
                NDS::channel::channel_type result;
                for ( const NDS::channel::channel_type val : channel_types_ )
                {
                    result = ( NDS::channel::channel_type )( result | val );
                }
                return result;
            }

            const data_type_list
            data_types( ) const
            {
                if ( data_types_.empty( ) )
                {
                    data_type_list result{ all_data_types };
                    return result;
                }
                return data_types_;
            }

            NDS::channel::data_type
            data_type_mask( ) const
            {
                if ( data_types_.empty( ) )
                {
                    return NDS::channel::DEFAULT_DATA_MASK;
                }
                NDS::channel::data_type result;
                for ( const NDS::channel::data_type val : data_types_ )
                {
                    result = ( NDS::channel::data_type )( result | val );
                }
                return result;
            }

            const frequency_range&
            sample_rates( ) const
            {
                return sample_rates_;
            }

            NDS::channel::sample_rate_type
            min_sample_rate( ) const
            {
                return sample_rates_.minimum;
            }

            NDS::channel::sample_rate_type
            max_sample_rate( ) const
            {
                return sample_rates_.maximum;
            }

            const epoch&
            time_span( ) const
            {
                return epoch_;
            }

            NDS::buffer::gps_second_type
            gps_start( ) const
            {
                return epoch_.gps_start;
            }

            NDS::buffer::gps_second_type
            gps_stop( ) const
            {
                return epoch_.gps_stop;
            }

            channel_predicate_object&
            set( std::string val )
            {
                glob_ = std::move( val );
                return *this;
            }

            void
            set_glob( std::string val )
            {
                set( val );
            }

            channel_predicate_object&
            set( NDS::channel::channel_type val )
            {
                {
                    for ( auto entry : all_channel_types )
                        if ( (int)entry | (int)val )
                        {
                            channel_types_.push_back( val );
                        }
                }
                return *this;
            }

            void
            set_channel_type_mask( NDS::channel::channel_type val )
            {
                set( val );
            }

            channel_predicate_object&
            set( NDS::channel::data_type val )
            {
                for ( auto entry : all_data_types )
                {
                    if ( (int)entry | (int)val )
                    {
                        data_types_.push_back( val );
                    }
                }
                return *this;
            }

            void
            set_data_type_mask( NDS::channel::data_type val )
            {
                set( val );
            }

            channel_predicate_object&
            set( frequency_range val )
            {
                sample_rates_ = val;
                return *this;
            }
            void
            set_frequency_range(
                NDS::channel::sample_rate_type min_sample_rate,
                NDS::channel::sample_rate_type max_sample_rate )
            {
                frequency_range range( min_sample_rate, max_sample_rate );
                set( range );
            }
            channel_predicate_object&
            set( epoch val )
            {
                epoch_ = val;
                return *this;
            }
            void
            set_timespan( NDS::buffer::gps_second_type gps_start,
                          NDS::buffer::gps_second_type gps_stop )
            {
                NDS::epoch e( "", gps_start, gps_stop );
                set( e );
            }

        private:
            DLL_EXPORT const static data_type_list    all_data_types;
            DLL_EXPORT const static channel_type_list all_channel_types;

            epoch             epoch_;
            std::string       glob_;
            channel_type_list channel_types_;
            data_type_list    data_types_;
            frequency_range   sample_rates_;
        };

        inline void
        build_channel_predicate( channel_predicate_object& pred )
        {
        }

        template < typename T >
        void
        build_channel_predicate( channel_predicate_object& pred, T val )
        {
            pred.set( val );
        }

        template < typename T, typename... Args >
        void
        build_channel_predicate( channel_predicate_object& pred,
                                 T                         val,
                                 Args... args )
        {
            pred.set( val );
            build_channel_predicate( pred, args... );
        }

        template < typename... Args >
        channel_predicate_object
        channel_predicate( Args... args )
        {
            channel_predicate_object pred;
            build_channel_predicate( pred, args... );
            return pred;
        }

        class connection
        {
        public:
            class error : public std::runtime_error
            {
            public:
                DLL_EXPORT
                error( const std::string& What, int ErrNo = 0 );
            };

            class already_closed_error : public error
            {
            public:
                DLL_EXPORT
                already_closed_error( );
            };

            class minute_trend_error : public error
            {
            public:
                DLL_EXPORT
                minute_trend_error( );
            };

            class transfer_busy_error : public error
            {
            public:
                DLL_EXPORT
                transfer_busy_error( );
            };

            class unexpected_channels_received_error : public error
            {
            public:
                DLL_EXPORT
                unexpected_channels_received_error( );
            };

            class daq_error : public error
            {
            public:
                DLL_EXPORT
                explicit daq_error( int daq_code );

                DLL_EXPORT
                daq_error( int                daq_code,
                           const std::string& additional_information );

                DLL_EXPORT
                daq_error( int daq_code, const char* additional_information );

                DLL_EXPORT
                inline int
                DAQCode( ) const
                {
                    return error_code;
                }

            private:
                int index;
                int error_code;

                static int counter_;

                static std::string format( int         DAQCode,
                                           const char* extra = nullptr );
            };

            typedef enum
            {
                PROTOCOL_INVALID = -1, 
                PROTOCOL_ONE = 1, 
                PROTOCOL_TWO = 2, 
                PROTOCOL_TRY = 3 
            } protocol_type;

            typedef std::string host_type; 
            typedef int         port_type; 
            typedef size_t      count_type; 

            typedef channel::channel_names_type channel_names_type;
            typedef std::vector< std::string >  parameters_type;

            static const port_type DEFAULT_PORT =
                31200; 

            DLL_EXPORT
            connection( ) = delete;

            DLL_EXPORT
            explicit connection( const host_type& host,
                                 port_type        port = DEFAULT_PORT,
                                 protocol_type    protocol = PROTOCOL_TRY );

            DLL_EXPORT
            explicit connection( const NDS::parameters& params );

            connection( const NDS::connection& other ) = delete;

            connection& operator=( const NDS::connection& other ) = delete;

            DLL_EXPORT
            ~connection( );

            DLL_EXPORT
            void close( );

            DLL_EXPORT
            count_type count_channels( const channel_predicate_object& pred );

            DLL_EXPORT channels_type
                       find_channels( const channel_predicate_object& pred );

            DLL_EXPORT epochs_type get_epochs( );

            DLL_EXPORT availability_list_type
                       get_availability( const epoch&              time_span,
                                         const channel_names_type& channel_names );

            DLL_EXPORT bool check( buffer::gps_second_type   gps_start,
                                   buffer::gps_second_type   gps_stop,
                                   const channel_names_type& channel_names );

            DLL_EXPORT buffers_type
                       fetch( buffer::gps_second_type   gps_start,
                              buffer::gps_second_type   gps_stop,
                              const channel_names_type& channel_names );

            DLL_EXPORT NDS::parameters& parameters( ) const;

            DLL_EXPORT const channel::hash_type& hash( ) const;

            DLL_EXPORT NDS::data_iterable
                       iterate( NDS::request_period       period,
                                const channel_names_type& channel_names );

            DLL_EXPORT bool request_in_progress( ) const;

        private:
            std::shared_ptr< detail::conn_p_type > p_;
        };

        DLL_EXPORT extern std::ostream& operator<<( std::ostream&     os,
                                                    const connection& conn );

        class parameters
        {
        public:
            DLL_EXPORT parameters( );
            DLL_EXPORT explicit parameters(
                const connection::host_type& host,
                connection::port_type        port = connection::DEFAULT_PORT,
                connection::protocol_type protocol = connection::PROTOCOL_TRY );

            DLL_EXPORT parameters( const parameters& other );
            DLL_EXPORT parameters( parameters&& other ) noexcept;

            DLL_EXPORT parameters& operator=( const parameters& other );
            DLL_EXPORT parameters& operator=( parameters&& other ) noexcept;

            DLL_EXPORT ~parameters( );

            DLL_EXPORT connection::host_type host( ) const;
            DLL_EXPORT connection::port_type port( ) const;
            DLL_EXPORT connection::protocol_type protocol( ) const;

            DLL_EXPORT std::string get( const std::string& key ) const;

            DLL_EXPORT bool set( const std::string& key,
                                 const std::string& value );

            DLL_EXPORT connection::parameters_type parameter_list( ) const;

        private:
            friend class NDS::detail::parameter_accessor;
            std::unique_ptr< detail::parameter_block > p_;
        };
    } // namespace abi_0
} // namespace NDS

#endif /* SWIG__COMMON__NDS_CONNECTION_HH */