icuSources/io/ustream.cpp

   1 /*
   2 **********************************************************************
   3 *   Copyright (C) 2001-2006, International Business Machines
   4 *   Corporation and others.  All Rights Reserved.
   5 **********************************************************************
   6 *  FILE NAME : ustream.cpp
   7 *
   8 *   Modification History:
   9 *
  10 *   Date        Name        Description
  11 *   06/25/2001  grhoten     Move iostream from unistr.h to here
  12 ******************************************************************************
  13 */
  14
  15
  16 #include "unicode/utypes.h"
  17 #include "unicode/uobject.h"
  18 #include "unicode/ustream.h"
  19 #include "unicode/ucnv.h"
  20 #include "unicode/uchar.h"
  21 #include "ustr_cnv.h"
  22 #include <string.h>
  23
  24 // console IO
  25
  26 #if U_IOSTREAM_SOURCE >= 198506
  27
  28 #if U_IOSTREAM_SOURCE >= 199711
  29 #define STD_NAMESPACE std::
  30 #else
  31 #define STD_NAMESPACE
  32 #endif
  33
  34 #define STD_OSTREAM STD_NAMESPACE ostream
  35 #define STD_ISTREAM STD_NAMESPACE istream
  36
  37 U_NAMESPACE_BEGIN
  38
  39 U_IO_API STD_OSTREAM & U_EXPORT2
  40 operator<<(STD_OSTREAM& stream, const UnicodeString& str)
  41 {
  42     if(str.length() > 0) {
  43         char buffer[200];
  44         UConverter *converter;
  45         UErrorCode errorCode = U_ZERO_ERROR;
  46
  47         // use the default converter to convert chunks of text
  48         converter = u_getDefaultConverter(&errorCode);
  49         if(U_SUCCESS(errorCode)) {
  50             const UChar *us = str.getBuffer();
  51             const UChar *uLimit = us + str.length();
  52             char *s, *sLimit = buffer + sizeof(buffer);
  53             do {
  54                 errorCode = U_ZERO_ERROR;
  55                 s = buffer;
  56                 ucnv_fromUnicode(converter, &s, sLimit, &us, uLimit, 0, FALSE, &errorCode);
  57
  58                 // write this chunk
  59                 if(s > buffer) {
  60                     stream.write(buffer, (int32_t)(s - buffer));
  61                 }
  62             } while(errorCode == U_BUFFER_OVERFLOW_ERROR);
  63             u_releaseDefaultConverter(converter);
  64         }
  65     }
  66
  67 /*    stream.flush();*/
  68     return stream;
  69 }
  70
  71 U_IO_API STD_ISTREAM & U_EXPORT2
  72 operator>>(STD_ISTREAM& stream, UnicodeString& str)
  73 {
  74     /* ipfx should eat whitespace when ios::skipws is set */
  75     UChar uBuffer[16];
  76     char buffer[16];
  77     int32_t idx = 0;
  78     UConverter *converter;
  79     UErrorCode errorCode = U_ZERO_ERROR;
  80
  81     str.truncate(0);
  82     // use the default converter to convert chunks of text
  83     converter = u_getDefaultConverter(&errorCode);
  84     if(U_SUCCESS(errorCode)) {
  85         UChar *us = uBuffer;
  86         const UChar *uLimit = uBuffer + sizeof(uBuffer)/sizeof(*uBuffer);
  87         const char *s, *sLimit;
  88         char ch;
  89         UChar ch32;
  90         UBool intialWhitespace = TRUE;
  91
  92         /* We need to consume one byte at a time to see what is considered whitespace. */
  93         while (!stream.eof()) {
  94             ch = stream.get();
  95             sLimit = &ch + 1;
  96             errorCode = U_ZERO_ERROR;
  97             us = uBuffer;
  98             s = &ch;
  99             ucnv_toUnicode(converter, &us, uLimit, &s, sLimit, 0, FALSE, &errorCode);
 100             if(U_FAILURE(errorCode)) {
 101                 /* Something really bad happened */
 102                 return stream;
 103             }
 104             /* Was the character consumed? */
 105             if (us != uBuffer) {
 106                 /* Reminder: ibm-1390 & JISX0213 can output 2 Unicode code points */
 107                 int32_t uBuffSize = us-uBuffer;
 108                 int32_t uBuffIdx = 0;
 109                 while (uBuffIdx < uBuffSize) {
 110                     U16_NEXT(uBuffer, uBuffIdx, uBuffSize, ch32);
 111                     if (u_isWhitespace(ch32)) {
 112                         if (!intialWhitespace) {
 113                             buffer[idx++] = ch;
 114                             while (idx > 0) {
 115                                 stream.putback(buffer[--idx]);
 116                             }
 117                             goto STOP_READING;
 118                         }
 119                         /* else skip intialWhitespace */
 120                     }
 121                     else {
 122                         str.append(ch32);
 123                         intialWhitespace = FALSE;
 124                     }
 125                 }
 126                 idx = 0;
 127             }
 128             else {
 129                 buffer[idx++] = ch;
 130             }
 131         }
 132 STOP_READING:
 133         u_releaseDefaultConverter(converter);
 134     }
 135
 136 /*    stream.flush();*/
 137     return stream;
 138 }
 139
 140 U_NAMESPACE_END
 141
 142 #endif
 143