---

tty.H

Go to the documentation of this file.

/*
 * Copyright 1997, Brown University, Providence, RI.
 * 
 *                         All Rights Reserved
 * 
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose other than its incorporation into a
 * commercial product is hereby granted without fee, provided that the
 * above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Brown University not be used in
 * advertising or publicity pertaining to distribution of the software
 * without specific, written prior permission.
 * 
 * BROWN UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ANY
 * PARTICULAR PURPOSE.  IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE FOR
 * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

/* -------------------------------------------------------------------------
               Public TTY include file
   ------------------------------------------------------------------------- */

#ifndef TTY_HAS_BEEN_INCLUDED
#define TTY_HAS_BEEN_INCLUDED

#include "std/dllimpexp.H"
#include "std/config.H"
#include "std/list.H"

class FD_EVENT {
   protected :
    int                       _fd;
    friend class FD_MANAGER;

   public :
                 FD_EVENT():_fd(-1)  { }
        virtual ~FD_EVENT() { }
    virtual void sample   () = 0;
    virtual void except   () { cerr << "What to do with an exception?" << endl;}
            int  fd       () { return _fd; }
};


class FD_TIMEOUT {
   public:
      virtual void timeout() = 0;
};
class DllImpExp FD_MANAGER {
   protected:
     ARRAY<FD_TIMEOUT *>        _timeouts;
     static FD_MANAGER         *_mgr;
     static ARRAY<FD_EVENT *>  *_pending_events;
     static ARRAY<FD_TIMEOUT *>*_pending_timeouts;
     static ARRAY<FD_EVENT *>  &pending_events()   { if (!_pending_events)
                                                      _pending_events = 
                                                         new ARRAY<FD_EVENT *>;
                                                     return *_pending_events; }
     static ARRAY<FD_TIMEOUT *>&pending_timeouts() { if (!_pending_timeouts)
                                                      _pending_timeouts = 
                                                        new ARRAY<FD_TIMEOUT *>;
                                                     return *_pending_timeouts;}
     virtual void               add(FD_EVENT *fd)          = 0;
     virtual void               rem(FD_EVENT *fd)          = 0;
     virtual void               add(FD_TIMEOUT *t) { _timeouts += t; }
     virtual void               rem(FD_TIMEOUT *t) { _timeouts -= t; }
   public : 
                         FD_MANAGER() { }
     virtual            ~FD_MANAGER() { }

     virtual void               loop(int infinite=1)        = 0;
     virtual ARRAY<FD_TIMEOUT*> timeouts()                 { return _timeouts; }
     static  FD_MANAGER        *mgr();
     static  void               set_mgr(FD_MANAGER *m)     { _mgr = m; 
                                  int i;
                                  for (i=0; i<pending_events().num();i++)
                                     m->add(pending_events()[i]);
                                  pending_events().clear();
                                  for (i=0; i<pending_timeouts().num();i++)
                                     m->add(pending_timeouts()[i]);
                                  pending_timeouts().clear();
                                }
     static  void rem_event(FD_EVENT *f) {
        if (_mgr) {
           _mgr->rem(f);
        } else {
           pending_events() -= f;
        }
     }
     static  void add_event(FD_EVENT *f) {
        if (_mgr) {
           _mgr->add(f);
        } else {
           pending_events() += f;
        }
     }
     static  void add_timeout(FD_TIMEOUT *to) {
        if (_mgr) {
           _mgr->add(to);
        } else {
           pending_timeouts() += to;
        }
     }
     static  void rem_timeout(FD_TIMEOUT *to) {
        if (_mgr) {
           _mgr->rem(to);
        } else {
           pending_timeouts() -= to;
        }
     }
};


class TTYfd_privates;
class DllImpExp TTYfd : public FD_EVENT {
  protected:
   enum             { MAX_REC_SIZE = 128 };

   char                    _dev[256];
   char                    _synch_buf[MAX_REC_SIZE];
   int                     _synch_pos;

   TTYfd_privates         &_privates;

  public:
   enum TTYparity {
     TTY_ODD,
     TTY_EVEN,
     TTY_NONE
   };
                TTYfd(const char *dev, const char *name);
                TTYfd();
   virtual     ~TTYfd()         { deactivate(); }

   virtual void sample          ()   { }
   virtual bool activate        ();
   virtual bool deactivate      ();

   int          open            ();
   int          close           ();
   int          not_configured  (int, int);
   int          clear           ();
   int          send_break      (int  duration);
   void         print_flags     ();
   int          set_speed       (long  speed);
   int          set_stopbits    (int   num);
   int          set_charsize    (short size);
   int          set_parity      (TTYparity parity);
   int          set_min_and_time(int min_num_chars,
                                 int min_delay_between_chars_or_total_time);
   int          set_flags();
   int          get_flags();
   int          read_synchronized(char sentinel, int sentinel_bit, int which, 
                                                    int record_size, char *buf);
   int          read_synchronized(char sentinel,    int record_size, char *buf);
   int          read_synchronized(int sentinel_bit, int record_size, char *buf);
   int          read_all        (char *buf, int maxbytes);
   int          nread           (char *buf, int readnum, int timeout_millisecs);
   int          drain           ();
   int          write           (const char *buf, int writenum,
                                 int timeout_millisecs);
   int          setup           ();
};

#endif /* TTY_HAS_BEEN_INCLUDED */

---