ACE/ace/IOStream_T.cpp

   1 #ifndef ACE_IOSTREAM_T_CPP
   2 #define ACE_IOSTREAM_T_CPP
   3
   4 #include "ace/IOStream_T.h"
   5 #include "ace/OS_Memory.h"
   6
   7 #if !defined (ACE_LACKS_PRAGMA_ONCE)
   8 # pragma once
   9 #endif /* ACE_LACKS_PRAGMA_ONCE */
  10
  11 #if !defined (ACE_LACKS_ACE_IOSTREAM)
  12
  13 #if !defined (__ACE_INLINE__)
  14 #include "ace/IOStream_T.inl"
  15 #endif /* !__ACE_INLINE__ */
  16
  17 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  18
  19 // We will be given a STREAM by the iostream object which creates us.
  20 // See the ACE_IOStream template for how that works.  Like other
  21 // streambuf objects, we can be input-only, output-only or both.
  22
  23 template <class STREAM>
  24 ACE_Streambuf_T<STREAM>::ACE_Streambuf_T (STREAM *peer,
  25                                           u_int streambuf_size,
  26                                           int io_mode)
  27   : ACE_Streambuf (streambuf_size, io_mode),
  28     peer_ (peer)
  29 {
  30   // A streambuf allows for unbuffered IO where every character is
  31   // read as requested and written as provided.  To me, this seems
  32   // terribly inefficient for socket-type operations, so I've disabled
  33   // it.  All of the work would be done by the underflow/overflow
  34   // functions anyway and I haven't implemented anything there to
  35   // support unbuffered IO.
  36
  37 #if !defined (ACE_LACKS_UNBUFFERED_STREAMBUF)
  38   this->unbuffered (0);
  39 #endif /* ! ACE_LACKS_UNBUFFERED_STREAMBUF */
  40
  41   // Linebuffered is similar to unbuffered.  Again, I don't have any
  42   // need for this and I don't see the advantage.  I believe this
  43   // would have to be supported by underflow/overflow to be effective.
  44 #if !defined (ACE_LACKS_LINEBUFFERED_STREAMBUF)
  45   this->linebuffered (0);
  46 #endif /* ! ACE_LACKS_LINEBUFFERED_STREAMBUF */
  47 }
  48
  49 template <class STREAM> ssize_t
  50 ACE_Streambuf_T<STREAM>::send (char *buf, ssize_t len)
  51 {
  52   return peer_->send_n (buf,len);
  53 }
  54
  55 template <class STREAM> ssize_t
  56 ACE_Streambuf_T<STREAM>::recv (char *buf,
  57                                ssize_t len,
  58                                ACE_Time_Value *tv)
  59 {
  60   return this->recv (buf, len, 0, tv);
  61 }
  62
  63 template <class STREAM> ssize_t
  64 ACE_Streambuf_T<STREAM>::recv (char *buf,
  65                                ssize_t len,
  66                                int flags,
  67                                ACE_Time_Value * tv)
  68 {
  69   this->timeout_ = 0;
  70   errno = ESUCCESS;
  71   ssize_t rval = peer_->recv (buf, len, flags, tv);
  72   if (errno == ETIME)
  73     this->timeout_ = 1;
  74   return rval;
  75 }
  76
  77 template <class STREAM> ssize_t
  78 ACE_Streambuf_T<STREAM>::recv_n (char *buf,
  79                                  ssize_t len,
  80                                  int flags,
  81                                  ACE_Time_Value *tv)
  82 {
  83   this->timeout_ = 0;
  84   errno = ESUCCESS;
  85   ssize_t rval = peer_->recv_n (buf, len, flags, tv);
  86   if (errno == ETIME)
  87     this->timeout_ = 1;
  88   return rval;
  89 }
  90
  91 template <class STREAM> ACE_HANDLE
  92 ACE_Streambuf_T<STREAM>::get_handle (void)
  93 {
  94   return peer_ ? peer_->get_handle () : 0;
  95 }
  96
  97 // The typical constructor.  This will initiailze your STREAM and then
  98 // setup the iostream baseclass to use a custom streambuf based on
  99 // STREAM.
 100
 101 template <class STREAM>
 102 ACE_IOStream<STREAM>::ACE_IOStream (STREAM &stream,
 103                                     u_int streambuf_size)
 104   : iostream (0),
 105     STREAM (stream)
 106 {
 107   ACE_NEW (streambuf_,
 108            ACE_Streambuf_T<STREAM> ((STREAM *) this,
 109                                     streambuf_size));
 110   iostream::init (this->streambuf_);
 111 }
 112
 113 template <class STREAM>
 114 ACE_IOStream<STREAM>::ACE_IOStream (u_int streambuf_size)
 115   : iostream (0)
 116 {
 117   ACE_NEW (this->streambuf_,
 118            ACE_Streambuf_T<STREAM> ((STREAM *) this,
 119                                     streambuf_size));
 120   iostream::init (this->streambuf_);
 121 }
 122
 123 // We have to get rid of the streambuf_ ourselves since we gave it to
 124 // iostream ()
 125
 126 template <class STREAM>
 127 ACE_IOStream<STREAM>::~ACE_IOStream (void)
 128 {
 129   delete this->streambuf_;
 130 }
 131
 132 // The only ambituity in the multiple inheritance is the close ()
 133 // function.
 134
 135 template <class STREAM> int
 136 ACE_IOStream<STREAM>::close (void)
 137 {
 138   return STREAM::close ();
 139 }
 140
 141 template <class STREAM> ACE_IOStream<STREAM> &
 142 ACE_IOStream<STREAM>::operator>> (ACE_Time_Value *&tv)
 143 {
 144   ACE_Time_Value *old_tv = this->streambuf_->recv_timeout (tv);
 145   tv = old_tv;
 146   return *this;
 147 }
 148
 149 #if defined (ACE_HAS_STRING_CLASS)
 150
 151 // A simple string operator.  The base iostream has 'em for char* but
 152 // that isn't always the best thing for a String.  If we don't provide
 153 // our own here, we may not get what we want.
 154
 155 template <class STREAM> ACE_IOStream<STREAM> &
 156 ACE_IOStream<STREAM>::operator>> (ACE_IOStream_String &v)
 157 {
 158   if (ipfx0 ())
 159     {
 160       char c;
 161       this->get (c);
 162
 163       for (v = c;
 164            this->get (c) && !isspace (c);
 165            v += c)
 166         continue;
 167     }
 168
 169   isfx ();
 170
 171   return *this;
 172 }
 173
 174 template <class STREAM> ACE_IOStream<STREAM> &
 175 ACE_IOStream<STREAM>::operator<< (ACE_IOStream_String &v)
 176 {
 177   if (opfx ())
 178     {
 179 #if defined (ACE_WIN32) && defined (_MSC_VER)
 180       for (int i = 0; i < v.GetLength (); ++i)
 181 #else
 182       for (u_int i = 0; i < (u_int) v.length (); ++i)
 183 #endif /* ACE_WIN32 && defined (_MSC_VER) */
 184         this->put (v[i]);
 185     }
 186
 187   osfx ();
 188
 189   return *this;
 190 }
 191
 192 // A more clever put operator for strings that knows how to deal with
 193 // quoted strings containing back-quoted quotes.
 194
 195 template <class STREAM> STREAM &
 196 operator>> (STREAM &stream,
 197             ACE_Quoted_String &str)
 198 {
 199   char c;
 200
 201   if (!(stream >> c)) // eat space up to the first char
 202     // stream.set (ios::eofbit|ios::failbit);
 203     return stream;
 204
 205   str = "";     // Initialize the string
 206
 207   // if we don't have a quote, append until we see space
 208   if (c != '"')
 209     for (str = c; stream.get (c) && !isspace (c); str += c)
 210       continue;
 211   else
 212     for (; stream.get (c) && c != '"'; str += c)
 213       if (c == '\\')
 214         {
 215           stream.get (c);
 216           if (c != '"')
 217             str += '\\';
 218         }
 219
 220   return stream;
 221 }
 222
 223 template <class STREAM> STREAM &
 224 operator<< (STREAM &stream,
 225             ACE_Quoted_String &str)
 226 {
 227   stream.put ('"');
 228
 229   for (u_int i = 0; i < str.length (); ++i)
 230     {
 231       if (str[i] == '"')
 232         stream.put ('\\');
 233       stream.put (str[i]);
 234     }
 235
 236   stream.put ('"');
 237
 238   return stream;
 239 }
 240
 241 ACE_END_VERSIONED_NAMESPACE_DECL
 242
 243 #endif /* ACE_HAS_STRING_CLASS */
 244 #endif /* ACE_LACKS_ACE_IOSTREAM */
 245 #endif /* ACE_IOSTREAM_T_CPP */