SerialStream.h

Go to the documentation of this file.

/*
 * Time-stamp: <04/05/05 15:25:22 pagey>
 *
 * $Id: SerialStream.h,v 1.9 2005/09/05 14:19:55 wedesoft Exp $
 *
 *
 */
#ifndef _SerialStream_h_
#define _SerialStream_h_

#ifndef _std_string_INCLUDED_
#    include <string>
#    define _std_string_INCLUDED_
#endif

#ifndef _std_fstream_INCLUDED_
#    include <fstream>
#    define _std_string_INCLUDED_
#endif

#ifndef _std_cassert_INCLUDED_
#    include <cassert>
#    define _std_cassert_INCLUDED_
#endif

#ifndef SerialStreamBuf_h
#    include <SerialStreamBuf.h>
#endif

extern "C++" {
    namespace LibSerial {
        class SerialStream : public std::iostream {
        public:





            /* ------------------------------------------------------------
             * Public Static Members
             * ------------------------------------------------------------ */





            explicit SerialStream( const std::string  filename, 
                                   std::ios_base::openmode mode =
                                   std::ios::in|std::ios::out) ;

            explicit SerialStream() ;
      
            virtual ~SerialStream() ; 

            void Open(const std::string filename, 
                      std::ios_base::openmode mode = 
                      std::ios_base::in | std::ios_base::out) ;

            void Close() ;

            const bool IsOpen() const ;

            void SetBaudRate(SerialStreamBuf::BaudRateEnum baud_rate) ;

            const SerialStreamBuf::BaudRateEnum BaudRate() ;

            void SetCharSize(const SerialStreamBuf::CharSizeEnum size) ;

            const SerialStreamBuf::CharSizeEnum CharSize() ;

            void SetNumOfStopBits(short stop_bits) ;

            const short NumOfStopBits() ; 

            void SetParity(const SerialStreamBuf::ParityEnum parity) ;

            const SerialStreamBuf::ParityEnum Parity() ;

            void 
            SetFlowControl(const SerialStreamBuf::FlowControlEnum flow_c) ;

            const SerialStreamBuf::FlowControlEnum FlowControl() ;

            const short SetVMin( short vtime ) ;

            const short VMin() ;

            const short SetVTime( short vtime ) ;

            const short VTime() ;




            /* ------------------------------------------------------------
             * Friends
             * ------------------------------------------------------------
             */
        protected:
            /* ------------------------------------------------------------
             * Protected Data Members
             * ------------------------------------------------------------
             */
            /* ------------------------------------------------------------
             * Protected Methods
             * ------------------------------------------------------------
             */
        private:
            /* ------------------------------------------------------------
             * Private Data Members
             * ------------------------------------------------------------
             */
            SerialStreamBuf *mIOBuffer ;

            /* ----------------------------------------------------------------
             * Private Methods
             * ----------------------------------------------------------------
             */
            /* Set the serial port to ignore the modem status lines. If the
               specified boolean parameter is false then the meaning of
               this function is reversed i.e. the serial port will start
               using the modem status lines.

               @param ignore If true then the modem status lines will be
               ignored otherwise they will be used during the
               communication.

            */
            //void IgnoreModemStatusLines(bool ignore=true) ;

            /* Enable the serial port receiver. This will allow us to read
               data from the serial port.
       
               @param enable If true then the received will be
               enabled. Otherwise it will be disabled.

            */
            //void EnableReceiver(bool enable=true) ;

        } ; // class SerialStream

        inline
        SerialStream::SerialStream() : 
          std::iostream(0), mIOBuffer(0) {
            //
            // Close the stream
            //
            Close() ;
        }

        inline
        SerialStream::~SerialStream() {
            // 
            // If a SerialStreamBuf is associated with this SerialStream
            // then we need to destroy it here.
            //
            if( mIOBuffer ) {
                delete mIOBuffer ;
            }
        }

        inline
        void 
        SerialStream::Close() {
            //
            // If a SerialStreamBuf is associated with the SerialStream then
            // destroy it.
            //
            if( mIOBuffer ) {
                delete mIOBuffer ;
                mIOBuffer = 0 ;
            }
        }

        inline
        const bool
        SerialStream::IsOpen() const {
            //
            // Checks to see if mIOBuffer is a null buffer, if not,
            // calls the is_open() function on this streams SerialStreamBuf,
            // mIOBuffer
            //
            if ( ! mIOBuffer ) {
                return false ;
            }
            return mIOBuffer->is_open() ;
        }

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

---