Pipe.h

Go to the documentation of this file.

#ifndef SZA_UTIL_PIPE_H
#define SZA_UTIL_PIPE_H

#ifdef PIPE_WAIT
#undef PIPE_WAIT
#endif

#ifdef PIPE_NOWAIT
#undef PIPE_NOWAIT
#endif

/*
 * Enumerate the two special I/O timeout values.
 */

/* Wait to complete the transaction */

#define PIPE_WAIT  -1 

/* Return immediately if the transaction would block */

#define PIPE_NOWAIT 0

/*
 * Enumerate the return statuses of read_pipe() and write_pipe().
 */
enum  PipeState {
  PIPE_OK,      /* The I/O completed successfully */
  PIPE_BUSY,    /* The I/O couldn't be performed without blocking */
  PIPE_ERROR    /* An error occurred */
};

#include <pthread.h> // Needed for POSIX thread function calls
#include <limits.h>  // PIPE_BUF 

namespace sza {
  namespace util {
    
    class Pipe {
      
    public:
    
      Pipe();
      
      virtual ~Pipe();
      
      virtual void readPipe(void *buffer, size_t nbyte, long timeout);
      
      virtual void writePipe(void *buffer, size_t nbyte, long timeout);

      virtual PipeState read(void *buffer, size_t nbyte, long timeout=PIPE_NOWAIT);
      
      virtual PipeState write(void *buffer, size_t nbyte, long timeout=PIPE_NOWAIT);
      
      int fd();
      
      fd_set rfds();
      
      int readFd() {return readfd_.fd_;};

      int writeFd() {return writefd_.fd_;};

    protected:
      
      pthread_mutex_t guard_;
      
      bool guardIsReady_;
      
      struct PipeFd {
        
        PipeFd();
        
        ~PipeFd();
        
        pthread_cond_t retry_; 
        
        bool retryIsReady_;
        
        int fd_; 
        
        void fillPipeFd();
      };
      
      PipeFd readfd_;
      
      PipeFd writefd_;
      
      /*
       * One can write up to PIPE_BUF bytes atomically, but there is no such
       * guarantee for read(). The following buffer allows this guarantee to
       * be extended to reads. It accumulates data sequentially from one
       * or more incomplete reads, and hands out request-sized chunks to
       * any readers that request <= nread bytes, on a first come first
       * served basis.
       */
      char unread_[PIPE_BUF];  
      
      size_t nread_;            
      
      void getTimeOfDay(struct timespec* ts);
      
    }; // End class Pipe
    
  }; // End namespace util
}; // End namespace sza

#endif // PIPE_H