--- a/preview.html Fri Nov 08 04:16:14 2013 +0900
+++ b/preview.html Fri Nov 08 05:07:35 2013 +0900
@@ -199,49 +199,62 @@
The example demonstrates how to read a chunk of data from a <a>ByteStream</a> using <code>read</code>. The <a>ByteStream</a> may of come from a <a href="#producers ">producer</a> such as <code>XMLHttpRequest</code>. Additionally, it demonstrates how to read a stream until an EOF is encountered.
</p>
- <pre class="example">
-// Read the first 1024 bytes of the stream as UTF-8
+ <pre class="example">// Read up to 1024 bytes from the ReadableByteStream
stream.readEncoding = "UTF-8";
stream.readType = "arraybuffer";
-Promise readPromise = stream.read(1024);
-readPromise.then(
- function(result) {
- console.log("Loaded" + result.size + " bytes");
- // Handle result.data
- },
- function(error) {
- // Handle error
- }
-);
-
-// Read data from the stream repeatedly
-function readUntilEof() {
- stream.read(1024).then(
- function(result) {
- // Handle read data
- someProcessFunction(result.data);
-
- // Print progress
- someReportFunction(result.size);
-
- if (!result.eof) {
- readUntilEof();
- }
+var result = stream.read(1024);
+if (result.eof) {
+ // EOF reached
+} else if (result.size == 0) {
+ result.data.then(
+ function (result) {
+ processData(result.data);
+ ...
},
- function(error) {
+ function (error) {
// Handle error
}
);
+} else {
+ // Done synchronously
+ processData(result.data);
+ ...
}</pre>
+ <pre class="example">// Read data from the ReadableByteStream repeatedly
+function readUntilEof() {
+ while (true) {
+ var result = stream.read();
+ if (result.eof) {
+ return;
+ } else if (result.size == 0) {
+ result.data.then(
+ function (result) {
+ processData(result.data);
+
+ if (!result.eof) {
+ readUntilEof();
+ }
+ },
+ function (error) {
+ // Handle error
+ }
+ );
+ } else {
+ processData(result.data);
+ }
+ }
+}
+
+readUntilEof();</pre>
+
<p>
In the example below, different code blocks handle progress, error, and success conditions.
The example below demonstrates how to obtain a <a>ReadableByteStream</a> from <a>XMLHttpRequest</a> to begin playing a large video in <code>readystate</code> LOADING.
The example takes the <a>ReadableByteStream</a> from a <a href="#producers">producer</a>, <a>XMLHttpRequest</a>, and gives to a <a href="#consumers">consumer</a>, the video tag.
</p>
- <pre class="example">
-function handler() {
+ <pre class="example">function handler() {
if(this.readyState == this.LOADING) {
var theStream = this.response;
var streamURL = URL.createObjectURL(theStream);
@@ -266,18 +279,18 @@
The example below demonstrates how to use <code>write()</code> to load a Stream into the audio tag, whose data could be processed and built dynamically at read time.
</p>
- <pre class="example">
-var theStream = new Stream("audio/mp3");
+ <pre class="example">var stream = new ByteStream("audio/mp3");
-function writeData(){
- var moreData;
+function writeData() {
// Do work to create more data to place into the stream
+ var data = generateMusic();
// If we have no more data to process and place in the stream, we close
if (moreData == null){
- theStream.writeClose();
+ stream.writeClose();
} else{
- theStream.write(moreData).then(
+ // Wait until write() completes.
+ stream.write(data).then(
function () {
writeData();
},
@@ -292,6 +305,21 @@
document.getElementById('audioTag').src = streamURL;
writeData();</pre>
+
+ <p>
+ If you have a producer code which should do work only when pulled, <code>waitForWritable()</code> should be used to wait for pull event.
+ </p>
+
+ <pre class="example">function poll() {
+ stream.waitForWritable().then(
+ function (pulledAmount) {
+ stream.write(generateRandomBytes(pulledAmount));
+ poll();
+ }
+ );
+}
+
+poll();</pre>
</section>
<section class="section" id="data_source">
@@ -405,8 +433,8 @@
The ReadableByteStream interface defines a protocol for APIs that produces byte stream:
<ol>
<li>How to receive a read request from the reader and output byte stream.</li>
- <li>How to transfer bulk data to other <a>WritableByteStream</a> (by pipe() method)</li>
- <li>How to mirror data to multiple destination <a>WritableByteStream</a>s (by fork() method)</li>
+ <li>How to transfer bulk data to other <a>WritableByteStream</a> (by <code>pipe()</code> method)</li>
+ <li>How to mirror data to multiple destination <a>WritableByteStream</a>s (by <code>fork()</code> method)</li>
</ol>
By returning a Promise and delaying fulfillment of it, the ReadableByteStream realizes asynchronous data consumption.