---

SerialStreamBuf.h

Go to the documentation of this file.

/*
 * Time-stamp: <00/08/08 01:24:02 pagey>
 *
 * $Id: SerialStreamBuf.h,v 1.1 2000/08/08 08:33:36 pagey Exp $ 
 *
 *
 */
#ifndef SerialStreamBuf_h
#define SerialStreamBuf_h

#include <termios.h>
#include <unistd.h>
#include <iosfwd>
#include <streambuf>
/* We need to figure out if we are using STLPORT implementation of the
   C++ Standard Template Library. If so, we need to start using the
   __STLPORT_STD namespace.

*/
#ifdef __STLPORT_STD
using namespace __STLPORT_STD ;
#define LIBSERIAL_STD __STLPORT_STD 
#else
#define LIBSERIAL_STD std
#endif

extern "C++" {
  namespace LibSerial {
    class SerialStreamBuf : public LIBSERIAL_STD::streambuf {
    public:


      enum BaudRateEnum {
        BAUD_50    = B50,         
        BAUD_75    = B75,         
        BAUD_110   = B110,        
        BAUD_134   = B134,        
        BAUD_150   = B150,        
        BAUD_200   = B200,        
        BAUD_300   = B300,        
        BAUD_600   = B600,        
        BAUD_1200  = B1200,       
        BAUD_1800  = B1800,       
        BAUD_2400  = B2400,       
        BAUD_4800  = B4800,       
        BAUD_9600  = B9600,       
        BAUD_19200 = B19200,      
        BAUD_38400 = B38400,      
        BAUD_INVALID              
      } ;

      enum CharSizeEnum {
        CHAR_SIZE_5 = CS5, 
        CHAR_SIZE_6 = CS6, 
        CHAR_SIZE_7 = CS7, 
        CHAR_SIZE_8 = CS8, 
        CHAR_SIZE_INVALID  
      } ;

      enum ParityEnum {
        PARITY_EVEN,     
        PARITY_ODD,      
        PARITY_NONE,     
        PARITY_INVALID   
      } ;      

      enum FlowControlEnum {
        FLOW_CONTROL_HARD,   
        FLOW_CONTROL_SOFT,   
        FLOW_CONTROL_INVALID 
      } ;

      /* ----------------------------------------------------------------------
       * Public Static Members
       * ----------------------------------------------------------------------
       */
      static const BaudRateEnum DEFAULT_BAUD ;

      static const CharSizeEnum DEFAULT_CHAR_SIZE ;

      static const short DEFAULT_NO_OF_STOP_BITS ;

      static const ParityEnum DEFAULT_PARITY ;
      
      static const FlowControlEnum DEFAULT_FLOW_CONTROL ;




      SerialStreamBuf() ;

      ~SerialStreamBuf() ;

      bool is_open() const ;

      SerialStreamBuf* open( const string filename, 
                             ios_base::openmode mode = 
                             ios_base::in | ios_base::out ) ;

      SerialStreamBuf* close() ;

      int SetParametersToDefault() ;

      const BaudRateEnum SetBaudRate(const BaudRateEnum baud_rate) ;

      const BaudRateEnum BaudRate() const ;

      const CharSizeEnum SetCharSize(const CharSizeEnum char_size) ;

      const CharSizeEnum CharSize() const ;

      short SetNumOfStopBits(short stop_bits) ;

      short NumOfStopBits() const ; 

      const ParityEnum SetParity(const ParityEnum parity) ;

      const ParityEnum Parity() const ;

      const FlowControlEnum SetFlowControl(const FlowControlEnum flow_c) ;

      const FlowControlEnum FlowControl() const ;



      /* ----------------------------------------------------------------------
       * Friends
       * ----------------------------------------------------------------------
       */
    protected:
      /* ----------------------------------------------------------------------
       * Protected Data Members
       * ----------------------------------------------------------------------
       */
      /* ----------------------------------------------------------------------
       * Protected Methods
       * ----------------------------------------------------------------------
       */
      virtual streambuf* setbuf(char_type *, streamsize) ;

      virtual int sync() ;

      virtual int showmanyc() ;

      virtual streamsize xsgetn(char_type *s, streamsize n) ;

      virtual int_type   underflow() ;

      virtual int_type   uflow() ;

      virtual int_type pbackfail(int_type c = traits_type::eof()) ;

      virtual streamsize xsputn(const char_type* s, streamsize n) ;

      virtual int_type   overflow(int_type c) ;

    private:
      /* ----------------------------------------------------------------------
       * Private Data Members
       * ----------------------------------------------------------------------
       */
      char mPutbackChar ;

      bool mPutbackAvailable ;
      
      int mFileDescriptor ;
      /* ----------------------------------------------------------------------
       * Private Methods
       * ----------------------------------------------------------------------
       */
      int InitializeSerialPort() ;
    } ; // class SerialStreamBuf

    inline 
    SerialStreamBuf::SerialStreamBuf() :
      mPutbackChar(0),
      mPutbackAvailable(false),
      mFileDescriptor(-1) {
      /* empty */
    }

    inline 
    SerialStreamBuf::~SerialStreamBuf() {
      if( this->is_open() ) {
        this->close() ;
      }
    }

    inline
    bool
    SerialStreamBuf::is_open() const {
      return (-1 != mFileDescriptor) ;
    }
    

  } ; // namespace LibSerial
} // extern "C++"
#endif // #ifndef SerialStreamBuf_h

---