Add writeString method to OutputStream

runtime/bin/string_stream.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // Interface for decoders decoding binary data into string data. The
 // decoder keeps track of line breaks during decoding.
 interface _StringDecoder {
   // Add more binary data to be decoded. The ownership of the buffer
   // is transfered to the decoder and the caller most not modify it any more.
   int write(List<int> buffer);
@@ skipping 10 matching lines @@
   String get decoded();
 
   // Get the string data decoded since the last call to [decode] or
   // [decodeLine] up to the next line break present. Returns null if
   // no line break is present. The line break character sequence is
   // discarded.
   String get decodedLine();
 }
 
 
+class _StringDecoders {
+  static _StringDecoder decoder(Encoding encoding) {
+    if (encoding == Encoding.UTF_8) {
+      return new _UTF8Decoder();
+    } else if (encoding == Encoding.ISO_8859_1) {
+      return new _Latin1Decoder();
+    } else if (encoding == Encoding.ASCII) {
+      return new _AsciiDecoder();
+    } else {
+      throw new StreamException("Unsupported encoding ${encoding.name}");
+    }
+  }
+}
+
+
 class DecoderException implements Exception {
   const DecoderException([String this.message]);
   String toString() => "DecoderException: $message";
   final String message;
 }
 
 
 // Utility class for decoding UTF-8 from data delivered as a stream of
 // bytes.
 class _StringDecoderBase implements _StringDecoder {
@@ skipping 94 matching lines @@
   Queue<int> _lineBreakEnds;  // Character position of known line breaks.
   int _charOffset = 0;  // Character number of the first character in the list.
   int _charCount = 0;  // Total number of characters decoded.
   int _lastCharCode = -1;
 
   final int LF = 10;
   final int CR = 13;
 }
 
 
+// Utility class for decoding UTF-8 from data delivered as a stream of
+// bytes.
+class _UTF8Decoder extends _StringDecoderBase {
+  // Process the next UTF-8 encoded character.
+  bool _processNext() {
+    // Peek the next byte to calculate the number of bytes required for
+    // the next character.
+    int value = _bufferList.peek() & 0xFF;
+    if ((value & 0x80) == 0x80) {
+      int additionalBytes;
+      if ((value & 0xe0) == 0xc0) {  // 110xxxxx
+        value = value & 0x1F;
+        additionalBytes = 1;
+      } else if ((value & 0xf0) == 0xe0) {  // 1110xxxx
+        value = value & 0x0F;
+        additionalBytes = 2;
+      } else {  // 11110xxx
+        value = value & 0x07;
+        additionalBytes = 3;
+      }
+      // Check if there are enough bytes to decode the character. Otherwise
+      // return false.
+      if (_bufferList.length < additionalBytes + 1) {
+        return false;
+      }
+      // Remove the value peeked from the buffer list.
+      _bufferList.next();
+      for (int i = 0; i < additionalBytes; i++) {
+        int byte = _bufferList.next();
+        value = value << 6 | (byte & 0x3F);
+      }
+    } else {
+      // Remove the value peeked from the buffer list.
+      _bufferList.next();
+    }
+    addChar(value);
+    return true;
+  }
+}
+
+
 // Utility class for decoding ascii data delivered as a stream of
 // bytes.
 class _AsciiDecoder extends _StringDecoderBase {
   // Process the next ascii encoded character.
   bool _processNext() {
     while (_bufferList.length > 0) {
       int byte = _bufferList.next();
       if (byte > 127) {
         throw new DecoderException("Illegal ASCII character $byte");
       }
@@ skipping 11 matching lines @@
   bool _processNext() {
     while (_bufferList.length > 0) {
       int byte = _bufferList.next();
       addChar(byte);
     }
     return true;
   }
 }
 
 
-// Utility class for decoding UTF-8 from data delivered as a stream of
-// bytes.
-class _UTF8Decoder extends _StringDecoderBase {
-  // Process the next UTF-8 encoded character.
-  bool _processNext() {
-    // Peek the next byte to calculate the number of bytes required for
-    // the next character.
-    int value = _bufferList.peek() & 0xFF;
-    if ((value & 0x80) == 0x80) {
+// Interface for encoders encoding string data into binary data.
+interface _StringEncoder {
+  List<int> encodeString(String string);
+}
+
+
+// Utility class for encoding a string into UTF-8 byte stream.
+class _UTF8Encoder implements _StringEncoder {
+  List<int> encodeString(String string) {
+    int size = _encodingSize(string);
+    ByteArray result = new ByteArray(size);
+    _encodeString(string, result);
+    return result;
+  }
+
+  static int _encodingSize(String string) => _encodeString(string, null);
+
+  static int _encodeString(String string, List<int> buffer) {
+    int pos = 0;
+    int length = string.length;
+    for (int i = 0; i < length; i++) {
       int additionalBytes;
-      if ((value & 0xe0) == 0xc0) {  // 110xxxxx
-        value = value & 0x1F;
+      int charCode = string.charCodeAt(i);
+      if (charCode <= 0x007F) {
+        additionalBytes = 0;
+        if (buffer != null) buffer[pos] = charCode;
+      } else if (charCode <= 0x07FF) {
+        // 110xxxxx (xxxxx is top 5 bits).
+        if (buffer != null) buffer[pos] = ((charCode >> 6) & 0x1F) | 0xC0;
         additionalBytes = 1;
-      } else if ((value & 0xf0) == 0xe0) {  // 1110xxxx
-        value = value & 0x0F;
+      } else if (charCode <= 0xFFFF) {
+        // 1110xxxx (xxxx is top 4 bits)
+        if (buffer != null) buffer[pos] = ((charCode >> 12) & 0x0F)| 0xE0;
         additionalBytes = 2;
-      } else {  // 11110xxx
-        value = value & 0x07;
+      } else {
+        // 11110xxx (xxx is top 3 bits)
+        if (buffer != null) buffer[pos] = ((charCode >> 18) & 0x07) | 0xF0;
         additionalBytes = 3;
       }
-      // Check if there are enough bytes to decode the character. Otherwise
-      // return false.
-      if (_bufferList.length < additionalBytes + 1) {
-        return false;
+      pos++;
+      if (buffer != null) {
+        for (int i = additionalBytes; i > 0; i--) {
+          // 10xxxxxx (xxxxxx is next 6 bits from the top).
+          buffer[pos++] = ((charCode >> (6 * (i - 1))) & 0x3F) | 0x80;
+        }
+      } else {
+        pos += additionalBytes;
       }
-      // Remove the value peeked from the buffer list.
-      _bufferList.next();
-      for (int i = 0; i < additionalBytes; i++) {
-        int byte = _bufferList.next();
-        value = value << 6 | (byte & 0x3F);
-      }
-    } else {
-      // Remove the value peeked from the buffer list.
-      _bufferList.next();
     }
-    addChar(value);
-    return true;
+    return pos;
   }
 }
 
 
+// Utility class for encoding a string into a Latin1 byte stream.
+class _Latin1Encoder implements _StringEncoder {
+  List<int> encodeString(String string) {
+    ByteArray result = new ByteArray(string.length);
+    for (int i = 0; i < string.length; i++) {
+      int charCode = string.charCodeAt(i);
+      if (charCode > 255) {
+        throw new EncoderException(
+            "No ISO_8859_1 encoding for code point $charCode");
+      }
+      result[i] = charCode;
+    }
+    return result;
+  }
+}
+
+
+// Utility class for encoding a string into an ASCII byte stream.
+class _AsciiEncoder implements _StringEncoder {
+  List<int> encodeString(String string) {
+    ByteArray result = new ByteArray(string.length);
+    for (int i = 0; i < string.length; i++) {
+      int charCode = string.charCodeAt(i);
+      if (charCode > 127) {
+        throw new EncoderException(
+            "No ASCII encoding for code point $charCode");
+      }
+      result[i] = charCode;
+    }
+    return result;
+  }
+}
+
+
+class _StringEncoders {
+  static _StringEncoder encoder(Encoding encoding) {
+    if (encoding == Encoding.UTF_8) {
+      return new _UTF8Encoder();
+    } else if (encoding == Encoding.ISO_8859_1) {
+      return new _Latin1Encoder();
+    } else if (encoding == Encoding.ASCII) {
+      return new _AsciiEncoder();
+    } else {
+      throw new StreamException("Unsupported encoding ${encoding.name}");
+    }
+  }
+}
+
+
+class EncoderException implements Exception {
+  const EncoderException([String this.message]);
+  String toString() => "EncoderException: $message";
+  final String message;
+}
+
+
 class _StringInputStream implements StringInputStream {
-  _StringInputStream(InputStream this._input, [String encoding])
+  _StringInputStream(InputStream this._input,
+                     [Encoding encoding = Encoding.UTF_8])
       : _encoding = encoding {
-    if (_encoding === null) {
-      _encoding = "UTF-8";
-    }
-    if (_encoding == "UTF-8") {
-      _decoder = new _UTF8Decoder();
-    } else if (_encoding == "ISO-8859-1") {
-      _decoder = new _Latin1Decoder();
-    } else if (_encoding == "ASCII") {
-      _decoder = new _AsciiDecoder();
-    } else {
-      throw new StreamException("Unsupported encoding $_encoding");
-    }
+    _decoder = _StringDecoders.decoder(encoding);
     _input.onData = _onData;
     _input.onClosed = _onClosed;
   }
 
   String read() {
     String result = _decoder.decoded;
     _checkInstallDataHandler();
     return result;
   }
 
   String readLine() {
     String decodedLine = _decoder.decodedLine;
     if (decodedLine == null) {
       if (_inputClosed) {
         // Last line might not have a line separator.
         decodedLine = _decoder.decoded;
         if (decodedLine != null &&
             decodedLine[decodedLine.length - 1] == '\r') {
           decodedLine = decodedLine.substring(0, decodedLine.length - 1);
         }
       }
     }
     _checkInstallDataHandler();
     return decodedLine;
   }
 
   int available() => _decoder.available();
 
-  String get encoding() => _encoding;
+  Encoding get encoding() => _encoding;
 
   bool get closed() => _inputClosed && _decoder.isEmpty();
 
   void set onData(void callback()) {
     _clientDataHandler = callback;
     _clientLineHandler = null;
     _checkInstallDataHandler();
     _checkScheduleCallback();
   }
 
@@ skipping 112 matching lines @@
       // Schedule close callback if no more data and input is closed.
       if (_decoder.isEmpty() &&
           _inputClosed &&
           _scheduledCloseCallback == null) {
         _scheduledCloseCallback = new Timer(0, issueCloseCallback);
       }
     }
   }
 
   InputStream _input;
-  String _encoding;
+  Encoding _encoding;
   _StringDecoder _decoder;
   bool _inputClosed = false;  // Is the underlying input stream closed?
   bool _closed = false;  // Is this stream closed.
   bool _eof = false;  // Has all data been read from the decoder?
   Timer _scheduledDataCallback;
   Timer _scheduledLineCallback;
   Timer _scheduledCloseCallback;
   Function _clientDataHandler;
   Function _clientLineHandler;
   Function _clientCloseHandler;
 }