endpoint.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2001 by Rick L. Vinyard, Jr.                            *
 *   rvinyard@cs.nmsu.edu                                                  *
 *                                                                         *
 *   This file is part of the conexus library.                             *
 *                                                                         *
 *   The conexus library is free software; you can redistribute it and/or  *
 *   modify it under the terms of the GNU General Public License           *
 *   version 3 as published by the Free Software Foundation.               *
 *                                                                         *
 *   The conexus library 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 software. If not see <http://www.gnu.org/licenses/>.  *
 ***************************************************************************/
#ifndef CONEXUSIO_H
#define CONEXUSIO_H

#include <set>
#include <queue>

#include <sys/select.h>

#include <glibmm/dispatcher.h>
#include <glibmm/thread.h>

#include <conexus/pointer.h>
#include <conexus/enums.h>
#include <conexus/except.h>
#include <conexus/data.h>
#include <conexus/object.h>

#define CONEXUS_ENDPOINT_GENERIC_CREATE() static Endpoint::pointer generic_create() { return create(); }

namespace Conexus
  {

    struct Timeout
    {
      Timeout( long int us=0 ): sec(0), nsec(us*1000) { }

      Timeout( long int s, long int ns ): sec(s), nsec(ns) { }

      operator struct timeval()
      {
        struct timeval tv;
        tv.tv_sec = sec;
        tv.tv_usec = nsec / 1000 + ((nsec%1000>=500)?1:0);
        return tv;
      }

      operator struct timespec()
      {
        struct timespec ts;
        ts.tv_sec = sec;
        ts.tv_nsec = nsec;
        return ts;
      }

      operator bool() { return sec > 0 && nsec >= 0; }

      operator double() { return sec + nsec/1000000000.0; }

      Timeout& operator=(const struct timeval& tv) { sec = tv.tv_sec; nsec = tv.tv_usec * 1000; return *this; }

      Timeout& operator=(const struct timespec& tv) { sec = tv.tv_sec; nsec = tv.tv_nsec; return *this; }

      bool operator==( const Timeout& other ) const { return sec == other.sec && nsec == other.nsec; }

      bool is_zero() const { return sec == 0 && nsec == 0; }

      bool is_null() const { return sec < 0 || nsec < 0; }

      long int sec;
      long int nsec;
    };

  class Endpoint: public Object
    {
      protected:
        
        Endpoint(bool close_on_destruct=true);

      public:

      typedef ConexusPointer<Endpoint> pointer;

      virtual ~Endpoint();

      virtual void start( );

      virtual void start( bool use_dispatcher );

      virtual void stop( );

      virtual bool is_running();

      virtual bool is_timestamping_received_data();

      virtual void set_timestamp_received_data(bool t=true);

      sigc::signal<void, const Data> signal_data();

      sigc::signal<void, size_t> signal_data_received_size();

      sigc::signal<void, size_t> signal_data_transmitted_size();

      sigc::signal<void> signal_opened();

      sigc::signal<void> signal_closed();

      sigc::signal<void,StartStop> signal_start_stop();

      sigc::signal<void> signal_eof();

      sigc::signal<void> signal_disconnected();

      const Timeout& default_read_timeout() const;

      void set_default_read_timeout( Timeout t );

      size_t fallback_read_size();

      void set_fallback_read_size(size_t s);

      const Timeout& default_write_timeout() const;

      void set_default_write_timeout( Timeout t );

      bool read_terminate_immediate();

      void set_read_terminate_immediate( bool i=true );

      virtual void open() throw (open_exception) = 0;

      virtual void close(bool force=false) throw (close_exception) = 0;

      ssize_t write(const void* data, size_t size) throw (write_exception);

      ssize_t write(const void* data, size_t size, Timeout timeout ) throw (write_exception);

      ssize_t write(Endpoint::pointer source, size_t block_size=65535, bool keep_open=true);
      
      ssize_t write(const Data data) throw (write_exception);

      ssize_t write(const Data data, Timeout timeout ) throw (write_exception);

      Data read( size_t size=0 ) throw (read_exception);

      Data read( size_t size, Timeout timeout ) throw (read_exception);

      Data read( Timeout timeout ) throw (read_exception);

      virtual size_t input_available() throw ();

      virtual void change_state(long new_state) throw (state_exception);

      long state();

      void set_close_on_destruct(bool value);

      bool close_on_destruct() const;

      void close_and_reopen(long state = ENDPOINT_UNCHANGED);

      bool is_open();

      bool is_closed();

    protected:
      bool m_use_blocking_reads;
      bool m_use_blocking_writes;
      
      Glib::Thread *m_read_thread;
      Glib::Thread *m_read_delivery_thread;
      bool m_read_terminate;
      bool m_read_terminate_immediate;

      Timeout m_default_read_timeout;
      size_t m_fallback_read_size;
      Timeout m_default_write_timeout;
      bool m_timestamp;

      Glib::Mutex m_read_queue_lock;

      Glib::Cond m_read_delivery_conditional;

      Glib::Dispatcher* m_dispatcher;
      bool m_use_dispatcher;

      sigc::signal<void, const Data> m_signal_data;
      sigc::signal<void, size_t> m_signal_data_received_size;
      sigc::signal<void, size_t> m_signal_data_transmitted_size;
      std::queue<Data> m_read_queue;

      virtual void read_thread_main();
      void read_thread_main_proxy();

      virtual void read_delivery_thread_main();

      void queue_received_data( const Data d );

      void emit_received_data( );

      
      bool m_close_on_destruct;
      long m_state;
      bool m_readable;
      bool m_writable;

      virtual void set_state_opened();
      virtual void set_state_closed();

      sigc::signal<void> m_signal_opened;
      sigc::signal<void> m_signal_closed;
      sigc::signal<void,StartStop> m_signal_start_stop;
      sigc::signal<void> m_signal_eof;
      sigc::signal<void> m_signal_disconnected;

      virtual size_t write_data(const Data data, Timeout timeout) throw (write_exception) = 0;

      virtual Data read_data( size_t size, Timeout timeout) throw (read_exception) = 0;
};

}

Conexus::Endpoint& operator<<(Conexus::Endpoint& io, const Conexus::Data d);
Conexus::Endpoint::pointer operator<<(Conexus::Endpoint::pointer io, const Conexus::Data d);
Conexus::Endpoint& operator>>(Conexus::Endpoint& io, Conexus::Data d);
Conexus::Endpoint::pointer operator>>(Conexus::Endpoint::pointer io, Conexus::Data d);

#endif