developer.intra2net.com Git - libi2ncommon/blob - src/pipestream.hxx

   1 /***************************************************************************
   2               inpipestream.hxx  -  C++ streambuffer wrapper
   3                              -------------------
   4     begin                : Thu Dec 27 2001
   5     copyright            : (C) 2001 by Intra2net AG
   6     email                : intranator@intra2net.com
   7  ***************************************************************************/
   8
   9 #ifndef _PIPESTREAM
  10 #define _PIPESTREAM
  11
  12 #include <string>
  13 #include <streambuf>
  14 #include <cstdio>
  15
  16 #include "exception.hxx"
  17
  18 // ATTENTION: A lot of mysterious STL bugs occured
  19 //            with a "real" buffer (buffer larger than 1 byte and up to 100 bytes)
  20 //            -> Keep it slow and working!
  21
  22 class inpipebuf : public std::streambuf
  23 {
  24 protected:
  25     char buffer;
  26     FILE *pipe;
  27
  28     // "callback" variables for destructor to store exit status
  29     bool *status_set;
  30     int *exit_status;
  31
  32 public:
  33     inpipebuf(const std::string& command)
  34     {
  35         status_set = NULL;
  36         exit_status = NULL;
  37
  38         pipe = popen (command.c_str(), "r");
  39         if (pipe == NULL)
  40             throw EXCEPTION (pipestream_error, "can't open program or permission denied");
  41
  42         // force underflow
  43         setg (&buffer, &buffer, &buffer);
  44     }
  45
  46     ~inpipebuf()
  47     {
  48         if (pipe != NULL) {
  49             int pclose_exit = pclose (pipe);
  50
  51             if (exit_status && pclose_exit != -1) {
  52                 *status_set = true;
  53                 *exit_status = pclose_exit;
  54             }
  55
  56             pipe = NULL;
  57         }
  58     }
  59
  60     void store_exit_status(bool *_status_set, int *_exit_status)
  61     { status_set = _status_set; exit_status = _exit_status; }
  62
  63 protected:
  64     virtual int_type underflow()
  65     {
  66         if (gptr() < egptr())
  67             return traits_type::to_int_type(*gptr());
  68
  69         buffer = fgetc (pipe);
  70         if (feof (pipe))
  71         {
  72             // ERROR or EOF
  73             return EOF;
  74         }
  75
  76         setg (&buffer, &buffer, &buffer+sizeof(char));
  77
  78         return traits_type::to_int_type(*gptr());
  79     }
  80 };
  81
  82 class inpipestream : public std::istream
  83 {
  84 protected:
  85     inpipebuf buf;
  86
  87 public:
  88     inpipestream(const std::string& command)
  89             : buf(command), std::istream(&buf)
  90     {}
  91
  92     void store_exit_status(bool *_status_set, int *_exit_status)
  93     { buf.store_exit_status(_status_set, _exit_status); }
  94 };
  95
  96 class outpipebuf : public std::streambuf
  97 {
  98 protected:
  99     FILE *pipe;
 100
 101     // "callback" variables for destructor to store exit status
 102     bool *status_set;
 103     int *exit_status;
 104
 105 public:
 106     outpipebuf(const std::string& command)
 107     {
 108         status_set = NULL;
 109         exit_status = NULL;
 110
 111         pipe = popen (command.c_str(), "w");
 112         if (pipe == NULL)
 113             throw EXCEPTION (pipestream_error, "can't open program or permission denied");
 114     }
 115
 116     ~outpipebuf()
 117     {
 118         if (pipe != NULL) {
 119             int pclose_exit = pclose (pipe);
 120
 121             if (exit_status && pclose_exit != -1) {
 122                 *status_set = true;
 123                 *exit_status = pclose_exit;
 124             }
 125
 126             pipe = NULL;
 127         }
 128     }
 129
 130     void store_exit_status(bool *_status_set, int *_exit_status)
 131     { status_set = _status_set; exit_status = _exit_status; }
 132
 133 protected:
 134     virtual int_type overflow(int_type c)
 135     {
 136         if (c != EOF)
 137         {
 138             if (fputc(c,pipe)==EOF)
 139                 return EOF;
 140         }
 141         return c;
 142     }
 143
 144     virtual std::streamsize xsputn(const char* s, std::streamsize num)
 145     {
 146         return fwrite(s,num,1,pipe);
 147     }
 148 };
 149
 150 class outpipestream : public std::ostream
 151 {
 152 protected:
 153     outpipebuf buf;
 154 public:
 155     outpipestream(const std::string& command)
 156             : buf(command), std::ostream(&buf)
 157     {}
 158
 159     void store_exit_status(bool *_status_set, int *_exit_status)
 160     { buf.store_exit_status(_status_set, _exit_status); }
 161 };
 162
 163 #endif