---

GPIBEquipment.h

Go to the documentation of this file.

/*
 * Time-stamp: <00/08/04 01:11:18 pagey>
 *
 * $Format: " * $Id: GPIBEquipment.h,v 0.11 2000/08/04 09:48:04 pagey Exp $"$
 * GPIBEquipment.h 1.2 Sun, 05 Mar 2000 05:10:09 -0800 pagey
 *
 */
#ifndef GPIBEquipment_h
#define GPIBEquipment_h

#include <iosfwd>
//
// If using the STLport version of the STL we need to include 
// streambuf and istream. 
//
#ifdef __STLPORT_STD
#include <streambuf>
#include <istream>
#endif
#include <string>
#include "LibGPIB.h"

extern "C++" {
  namespace LibGPIB {
    class GPIBController ;
    class GPIBEquipment ;

    class GPIBEquipmentBuffer : public streambuf {
#ifdef __GNUG__
      //
      // GNU GCC implementation of STL does not define these in
      // streambuf so we have to define them manually. 
      //
      typedef char char_type ;
      typedef int  int_type ;
      typedef int  streamsize ;
#endif
    public:
      GPIBEquipmentBuffer(GPIBEquipment *device) ;
    protected:
      virtual streambuf* setbuf(char_type *, streamsize) ;
      
      virtual int_type   overflow(int_type c) ;

      virtual int_type   uflow() ;

      virtual int_type   underflow() ;

      virtual streamsize xsgetn(char_type *s, streamsize n) ;
      
      virtual streamsize xsputn(const char_type* s, streamsize n) ;
      
      virtual int_type pbackfail(int_type c = EOF) ;
    private:
      GPIBEquipment *mParentGPIBEquipment ;

      char mPutbackChar ;

      bool mPutbackAvailable ;
      
      char_type GetChar() ;

      void PutChar(const char_type c) ;
    } ;

    inline 
    GPIBEquipmentBuffer::GPIBEquipmentBuffer(GPIBEquipment *device) :
      mParentGPIBEquipment(device), 
      mPutbackAvailable(false),
      mPutbackChar(0) {
      //
      // The I/O from/to the GPIBEquipment will always be unbuffered.
      //
      setbuf(0, 0) ;
    }

    inline 
    streambuf *
    GPIBEquipmentBuffer::setbuf(char_type *, streamsize) {
      //
      // We force unbuffered I/O even if someone tries to provide 
      // a buffer. 
      //
      return streambuf::setbuf(0, 0) ;
    }
    
    inline
    GPIBEquipmentBuffer::int_type 
    GPIBEquipmentBuffer::overflow(int_type c) {
      PutChar(c) ;
      return c ;
    }

    inline
    GPIBEquipmentBuffer::int_type
    GPIBEquipmentBuffer::underflow() {
      return GetChar() ;
    }

    inline
    GPIBEquipmentBuffer::int_type
    GPIBEquipmentBuffer::uflow() {
      return GetChar() ;
    }
    

    inline
    GPIBEquipmentBuffer::int_type 
    GPIBEquipmentBuffer::pbackfail(int_type c) {
      mPutbackChar = c ;
      mPutbackAvailable = true ;
      return c ;
    }

    class GPIBEquipment : public iostream {
    public: 
      friend GPIBEquipmentBuffer ;

      void SetController(GPIBController *controller) ;

      void Clear() ;

      int PrimAddress(const int addr) ;

      int PrimAddress() const ; 

      int SecAddress(const int addr) ;

      int SecAddress() const ; 

      int DeviceID() const ;

      void SendCommand(const string command) ;

      const string ReadData(int read_bytes) ;

      void SetLocal() ;

      GPIBEquipment() ;

      virtual ~GPIBEquipment()  ;
      
      /* A template function to intercept all I/O operations for this
          class and direct them to the corresponding functions of the
          GPIBController class.

      */
      //template <class ValueType> 
      //ostream& operator<<(ValueType val) {
      //if( mController ) {
      //mController << mController.SendCommandPrefix(PrimAddress(), SecAddress()) 
      //<< val << mController.SendCommandPostfix(PrimAddress(), SecAddress()) ;
      //}
      //}

      //template <class ValueType>
      //istream& operator>>(ValueType& val) {
      //if (mController) {
      //mController << mController.ReadDataPrefix(PrimAddress(), SecAddress()) ;
      //mController >> val ;
      //mController << mController.ReadDataPostfix(PrimAddress(), SecAddress()) ;
      //}
      //}

    private:
      int mAddress ;

      int mSecAddress ;

      GPIBController *mController ;
      
      GPIBEquipmentBuffer *mBuffer ;
    protected:
      int mDeviceID ;

      GPIBController& Controller() ;
    } ;


    inline 
    int 
    GPIBEquipment::PrimAddress(const int addr) { mAddress = addr ; return mAddress ; }

    inline 
    int 
    GPIBEquipment::PrimAddress() const { return mAddress ; } 

    inline 
    int 
    GPIBEquipment::SecAddress(const int addr) { return mSecAddress = addr ; } 

    inline 
    int 
    GPIBEquipment::SecAddress() const { return mSecAddress ; } 

    inline 
    int 
    GPIBEquipment::DeviceID() const { return mDeviceID ; }
  } // namespace LibGPIB
}  // extern "C++"
#endif

---