Add .gitignore and .ratignore files for various directories

guacamole-common-js/src/main/webapp/modules/StringWriter.js

@@ -0,0 +1,205 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+var Guacamole = Guacamole || {};
+
+/**
+ * A writer which automatically writes to the given output stream with text
+ * data.
+ * 
+ * @constructor
+ * @param {!Guacamole.OutputStream} stream
+ *     The stream that data will be written to.
+ */
+Guacamole.StringWriter = function(stream) {
+
+    /**
+     * Reference to this Guacamole.StringWriter.
+     *
+     * @private
+     * @type {!Guacamole.StringWriter}
+     */
+    var guac_writer = this;
+
+    /**
+     * Wrapped Guacamole.ArrayBufferWriter.
+     *
+     * @private
+     * @type {!Guacamole.ArrayBufferWriter}
+     */
+    var array_writer = new Guacamole.ArrayBufferWriter(stream);
+
+    /**
+     * Internal buffer for UTF-8 output.
+     *
+     * @private
+     * @type {!Uint8Array}
+     */
+    var buffer = new Uint8Array(8192);
+
+    /**
+     * The number of bytes currently in the buffer.
+     *
+     * @private
+     * @type {!number}
+     */
+    var length = 0;
+
+    // Simply call onack for acknowledgements
+    array_writer.onack = function(status) {
+        if (guac_writer.onack)
+            guac_writer.onack(status);
+    };
+
+    /**
+     * Expands the size of the underlying buffer by the given number of bytes,
+     * updating the length appropriately.
+     * 
+     * @private
+     * @param {!number} bytes
+     *     The number of bytes to add to the underlying buffer.
+     */
+    function __expand(bytes) {
+
+        // Resize buffer if more space needed
+        if (length+bytes >= buffer.length) {
+            var new_buffer = new Uint8Array((length+bytes)*2);
+            new_buffer.set(buffer);
+            buffer = new_buffer;
+        }
+
+        length += bytes;
+
+    }
+
+    /**
+     * Appends a single Unicode character to the current buffer, resizing the
+     * buffer if necessary. The character will be encoded as UTF-8.
+     * 
+     * @private
+     * @param {!number} codepoint
+     *     The codepoint of the Unicode character to append.
+     */
+    function __append_utf8(codepoint) {
+
+        var mask;
+        var bytes;
+
+        // 1 byte
+        if (codepoint <= 0x7F) {
+            mask = 0x00;
+            bytes = 1;
+        }
+
+        // 2 byte
+        else if (codepoint <= 0x7FF) {
+            mask = 0xC0;
+            bytes = 2;
+        }
+
+        // 3 byte
+        else if (codepoint <= 0xFFFF) {
+            mask = 0xE0;
+            bytes = 3;
+        }
+
+        // 4 byte
+        else if (codepoint <= 0x1FFFFF) {
+            mask = 0xF0;
+            bytes = 4;
+        }
+
+        // If invalid codepoint, append replacement character
+        else {
+            __append_utf8(0xFFFD);
+            return;
+        }
+
+        // Offset buffer by size
+        __expand(bytes);
+        var offset = length - 1;
+
+        // Add trailing bytes, if any
+        for (var i=1; i<bytes; i++) {
+            buffer[offset--] = 0x80 | (codepoint & 0x3F);
+            codepoint >>= 6;
+        }
+
+        // Set initial byte
+        buffer[offset] = mask | codepoint;
+
+    }
+
+    /**
+     * Encodes the given string as UTF-8, returning an ArrayBuffer containing
+     * the resulting bytes.
+     * 
+     * @private
+     * @param {!string} text
+     *     The string to encode as UTF-8.
+     *
+     * @return {!Uint8Array}
+     *     The encoded UTF-8 data.
+     */
+    function __encode_utf8(text) {
+
+        // Fill buffer with UTF-8
+        for (var i=0; i<text.length; i++) {
+            var codepoint = text.charCodeAt(i);
+            __append_utf8(codepoint);
+        }
+
+        // Flush buffer
+        if (length > 0) {
+            var out_buffer = buffer.subarray(0, length);
+            length = 0;
+            return out_buffer;
+        }
+
+    }
+
+    /**
+     * Sends the given text.
+     * 
+     * @param {!string} text
+     *     The text to send.
+     */
+    this.sendText = function(text) {
+        if (text.length)
+            array_writer.sendData(__encode_utf8(text));
+    };
+
+    /**
+     * Signals that no further text will be sent, effectively closing the
+     * stream.
+     */
+    this.sendEnd = function() {
+        array_writer.sendEnd();
+    };
+
+    /**
+     * Fired for received data, if acknowledged by the server.
+     *
+     * @event
+     * @param {!Guacamole.Status} status
+     *     The status of the operation.
+     */
+    this.onack = null;
+
+};