merging javascript branch

1 files changed, 773 insertions, 0 deletions

diff --git a/js/src/Ice/Operation.js b/js/src/Ice/Operation.js
new file mode 100644
index 00000000000..11a130f542f
--- /dev/null
+++ b/js/src/Ice/Operation.js
@@ -0,0 +1,773 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+(function(global){
+    require("Ice/Class");
+    require("Ice/Current");
+    require("Ice/DispatchStatus");
+    require("Ice/Exception");
+    require("Ice/FormatType");
+    require("Ice/Object");
+    require("Ice/ObjectPrx");
+    require("Ice/OptionalFormat");
+    require("Ice/StreamHelpers");
+
+    var Ice = global.Ice || {};
+    var Slice = global.Slice || {};
+    
+    /*jshint -W069 */
+
+    var Class = Ice.Class;
+
+    var builtinHelpers =
+    [
+        Ice.ByteHelper,
+        Ice.BoolHelper,
+        Ice.ShortHelper,
+        Ice.IntHelper,
+        Ice.LongHelper,
+        Ice.FloatHelper,
+        Ice.DoubleHelper,
+        Ice.StringHelper,
+        Ice.Object,
+        Ice.ObjectPrx
+    ];
+
+    function parseParam(p)
+    {
+        var type = p[0];
+        var t = typeof(type);
+        if(t === 'number')
+        {
+            type = builtinHelpers[p[0]];
+        }
+        else if(t === 'string')
+        {
+            /*jshint -W061 */
+            type = eval(type);
+            /*jshint +W061 */
+        }
+        
+        return {
+            "type": type,
+            "isObject": (p[1] === true),
+            "tag": p[2] // Optional tag, which may not be present - an undefined tag means "not optional".
+        };
+    }
+
+    //
+    // Each operation descriptor is a property. The key is the "on-the-wire"
+    // name, and the value is an array consisting of the following elements:
+    //
+    //  0: native method name in case of a keyword conflict (e.g., "_while"),
+    //     otherwise an empty string
+    //  1: mode (undefined == Normal or int)
+    //  2: sendMode (undefined == Normal or int)
+    //  3: amd (undefined or 1)
+    //  4: format (undefined == Default or int)
+    //  5: return type (undefined if void, or [type, tag])
+    //  6: in params (undefined if none, or array of [type, tag])
+    //  7: out params (undefined if none, or array of [type, tag])
+    //  8: exceptions (undefined if none, or array of types)
+    //  9: sends classes (true or undefined)
+    // 10: returns classes (true or undefined)
+    //
+    function parseOperation(name, arr)
+    {
+        var r = {};
+        var i;
+        var p;
+
+        r["name"] = name;
+        r["mode"] = arr[1] ? Ice.OperationMode.valueOf(arr[1]) : Ice.OperationMode.Normal;
+        r["sendMode"] = arr[2] ? Ice.OperationMode.valueOf(arr[2]) : Ice.OperationMode.Normal;
+        r["amd"] = arr[3] ? true : false;
+        r["format"] = arr[4] ? Ice.FormatType.valueOf(arr[4]) : Ice.FormatType.DefaultFormat;
+
+        if(r["amd"])
+        {
+            r["servantMethod"] = name + "_async";
+        }
+        else
+        {
+            r["servantMethod"] = arr[0] ? arr[0] : name;
+        }
+
+        var ret;
+        if(arr[5])
+        {
+            ret = parseParam(arr[5]);
+            ret["pos"] = 0;
+        }
+        r["returns"] = ret;
+
+        var inParams = [];
+        var inParamsOpt = [];
+        if(arr[6])
+        {
+            for(i = 0; i < arr[6].length; ++i)
+            {
+                p = parseParam(arr[6][i]);
+                p["pos"] = i;
+                inParams.push(p);
+                if(p.tag)
+                {
+                    inParamsOpt.push(p);
+                }
+            }
+        }
+        inParamsOpt.sort(function(p1, p2) { return p1.tag - p2.tag; }); // Sort by tag.
+        r["inParams"] = inParams;
+        r["inParamsOpt"] = inParamsOpt;
+
+        var outParams = [];
+        var outParamsOpt = [];
+        if(arr[7])
+        {
+            var offs = ret ? 1 : 0;
+            for(i = 0; i < arr[7].length; ++i)
+            {
+                p = parseParam(arr[7][i]);
+                p["pos"] = i + offs;
+                outParams.push(p);
+                if(p.tag)
+                {
+                    outParamsOpt.push(p);
+                }
+            }
+        }
+        if(ret && ret.tag)
+        {
+            outParamsOpt.push(ret);
+        }
+        outParamsOpt.sort(function(p1, p2) { return p1.tag - p2.tag; }); // Sort by tag.
+        r["outParams"] = outParams;
+        r["outParamsOpt"] = outParamsOpt;
+
+        var exceptions = [];
+        if(arr[8])
+        {
+            for(i = 0; i < arr[8].length; ++i)
+            {
+                exceptions.push(arr[8][i]);
+            }
+        }
+        r["exceptions"] = exceptions;
+
+        r["sendsClasses"] = arr[9] === true;
+        r["returnsClasses"] = arr[10] === true;
+
+        return r;
+    }
+
+    var OpTable = Class({
+        __init__: function(ops)
+        {
+            this.raw = ops;
+            this.parsed = {};
+        },
+        find: function(name)
+        {
+            //
+            // Check if we've already parsed the operation.
+            //
+            var op = this.parsed[name];
+            if(op === undefined && this.raw[name] !== undefined)
+            {
+                //
+                // We haven't parsed it yet, but we found a match for the name, so parse it now.
+                //
+                op = parseOperation(name, this.raw[name]);
+                this.parsed[name] = op;
+            }
+            return op;
+        }
+    });
+
+    function unmarshalParams(is, retvalInfo, allParamInfo, optParamInfo, usesClasses, params, offset)
+    {
+        var i, p, v;
+        //
+        // First read all required params.
+        //
+        for(i = 0; i < allParamInfo.length; ++i)
+        {
+            p = allParamInfo[i];
+            if(!p.tag)
+            {
+                v = p.type.read(is);
+                params[p.pos + offset] = v;
+            }
+        }
+
+        //
+        // Then read a required return value (if any).
+        //
+        if(retvalInfo)
+        {
+            v = retvalInfo.type.read(is);
+            params[retvalInfo.pos + offset] = v;
+        }
+
+        //
+        // Then read all optional params.
+        //
+        for(i = 0; i < optParamInfo.length; ++i)
+        {
+            p = optParamInfo[i];
+            v = p.type.readOpt(is, p.tag);
+            params[p.pos + offset] = v;
+        }
+
+        if(usesClasses)
+        {
+            is.readPendingObjects();
+        }
+    }
+
+    function marshalParams(os, params, retvalInfo, paramInfo, optParamInfo, usesClasses)
+    {
+        var i, p;
+
+        //
+        // Write the required params.
+        //
+        for(i = 0; i < paramInfo.length; ++i)
+        {
+            p = paramInfo[i];
+            if(!p.tag)
+            {
+                p.type.write(os, params[p.pos]);
+            }
+        }
+
+        //
+        // retvalInfo should only be provided if there is a non-void required return value.
+        //
+        if(retvalInfo)
+        {
+            retvalInfo.type.write(os, params[retvalInfo.pos]);
+        }
+
+        //
+        // Write the optional params.
+        //
+        for(i = 0; i < optParamInfo.length; ++i)
+        {
+            p = optParamInfo[i];
+            p.type.writeOpt(os, p.tag, params[p.pos]);
+        }
+
+        if(usesClasses)
+        {
+            os.writePendingObjects();
+        }
+    }
+
+    var Upcall = Class({
+        __init__: function(incomingAsync, op)
+        {
+            this.incomingAsync = incomingAsync;
+            this.op = op;
+        },
+        ice_response: function()
+        {
+            var args = arguments;
+
+            if(this.incomingAsync.__validateResponse(true))
+            {
+                try
+                {
+                    this.__sendResponse(args);
+                    this.incomingAsync.__response();
+                }
+                catch(ex)
+                {
+                    this.incomingAsync.__exception(ex);
+                }
+            }
+        },
+        ice_exception: function(ex)
+        {
+            if(this.__checkException(ex))
+            {
+                if(this.incomingAsync.__validateResponse(false))
+                {
+                    this.__sendException(ex);
+                    this.incomingAsync.__response();
+                }
+            }
+            else
+            {
+                this.incomingAsync.ice_exception(ex);
+            }
+        },
+        __sendResponse: function(results)
+        {
+            if(this.op.returns === undefined && this.op.outParams.length === 0)
+            {
+                if(results && results.length > 0)
+                {
+                    //
+                    // No results expected.
+                    //
+                    throw new Error("ice_response called with invalid arguments");
+                }
+                else
+                {
+                    this.incomingAsync.__writeEmptyParams();
+                }
+            }
+            else
+            {
+                var __os = this.incomingAsync.__startWriteParams(this.op.format);
+                var retvalInfo;
+                if(this.op.returns && !this.op.returns.tag)
+                {
+                    retvalInfo = this.op.returns;
+                }
+                marshalParams(__os, results, retvalInfo, this.op.outParams, this.op.outParamsOpt,
+                              this.op.returnsClasses);
+                this.incomingAsync.__endWriteParams(true);
+            }
+        },
+        __checkException: function(ex)
+        {
+            //
+            // Make sure the given exception is an instance of one of the declared user exceptions
+            // for this operation.
+            //
+            for(var i = 0; i < this.op.exceptions.length; ++i)
+            {
+                if(ex instanceof this.op.exceptions[i])
+                {
+                    //
+                    // User exception is valid.
+                    //
+                    return true;
+                }
+            }
+
+            return false;
+        },
+        __sendException: function(ex)
+        {
+            //
+            // User exception is valid, now marshal it.
+            //
+            this.incomingAsync.__writeUserException(ex, this.op.format);
+        }
+    });
+
+    var __dispatchImpl = function(servant, op, incomingAsync, current)
+    {
+        //
+        // Check to make sure the servant implements the operation.
+        //
+        var method = servant[op.servantMethod];
+        if(method === undefined || typeof(method) !== "function")
+        {
+            var comm = current.adapter.getCommunicator();
+            var msg = "servant for identity " + comm.identityToString(current.id) +
+                " does not define operation `" + op.servantMethod + "'";
+            console.log(msg);
+            throw new Ice.UnknownException(msg);
+        }
+
+        var up = new Upcall(incomingAsync, op);
+
+        try
+        {
+            //
+            // Unmarshal the in params (if any).
+            //
+            var params = op.amd ? [null] : [];
+            if(op.inParams.length === 0)
+            {
+                incomingAsync.readEmptyParams();
+            }
+            else
+            {
+                var __is = incomingAsync.startReadParams();
+                var offset = op.amd ? 1 : 0;
+                unmarshalParams(__is, undefined, op.inParams, op.inParamsOpt, op.sendsClasses, params, offset);
+                incomingAsync.endReadParams();
+
+                //
+                // When unmarshaling objects, the ObjectHelper returns a wrapper object
+                // and eventually stores the unmarshaled object into its "value" member.
+                // Here we scan the parameter array and replace the wrappers with the
+                // actual object references.
+                //
+                if(op.inParams.length > 0 && (op.sendsClasses || op.inParamsOpt.length > 0))
+                {
+                    for(var i = 0; i < op.inParams.length; ++i)
+                    {
+                        var p = op.inParams[i];
+                        //
+                        // Optional parameters may be undefined.
+                        //
+                        if(p.isObject && params[p.pos + offset] !== undefined)
+                        {
+                            params[p.pos + offset] = params[p.pos + offset].value;
+                        }
+                    }
+                }
+            }
+
+            params.push(current);
+
+            if(op.amd)
+            {
+                params[0] = up; // The AMD callback object.
+                try
+                {
+                    method.apply(servant, params);
+                }
+                catch(ex)
+                {
+                    up.ice_exception(ex);
+                }
+                return Ice.DispatchStatus.DispatchAsync;
+            }
+            else
+            {
+                //
+                // Determine how many out parameters to expect.
+                //
+                var numExpectedResults = op.outParams.length;
+                if(op.returns)
+                {
+                    ++numExpectedResults;
+                }
+
+                var results = method.apply(servant, params);
+
+                //
+                // Complain if we expect more than out parameter and the servant doesn't return an array.
+                //
+                if(numExpectedResults > 1 && !(results instanceof Array))
+                {
+                    var msg = "operation `" + op.servantMethod + "' should return an array of length " + numParams;
+                    console.log(msg);
+                    throw new Ice.MarshalException(msg);
+                }
+                else if(numExpectedResults === 1)
+                {
+                    //
+                    // Wrap a single out parameter in an array.
+                    //
+                    results = [results];
+                }
+
+                up.__sendResponse(results);
+                return Ice.DispatchStatus.DispatchOK;
+            }
+        }
+        catch(ex)
+        {
+            if(up.__checkException(ex))
+            {
+                up.__sendException(ex);
+                return Ice.DispatchStatus.DispatchUserException;
+            }
+            else
+            {
+                throw ex;
+            }
+        }
+    };
+
+    function getServantMethodFromInterfaces(interfaces, methodName, all)
+    {
+        var method;
+        for(var i = 0; method === undefined && i < interfaces.length; ++i)
+        {
+            var intf = interfaces[i];
+            method = intf[methodName];
+            if(method === undefined)
+            {
+                if(all.indexOf(intf) === -1)
+                {
+                    all.push(intf);
+                }
+                if(intf.__implements)
+                {
+                    method = getServantMethodFromInterfaces(intf.__implements, methodName, all);
+                }
+            }
+        }
+        return method;
+    }
+
+    var dispatchPrefix = "__op_";
+
+    function getServantMethod(servantType, name)
+    {
+        //
+        // The dispatch method is named __op_<Slice name> and is stored in the type (not the prototype).
+        //
+        var methodName = dispatchPrefix + name;
+
+        //
+        // First check the servant type.
+        //
+        var method = servantType[methodName];
+
+        var allInterfaces;
+
+        if(method === undefined)
+        {
+            allInterfaces = [];
+
+            //
+            // Now check the prototypes of the implemented interfaces.
+            //
+            var curr = servantType;
+            while(curr && method === undefined)
+            {
+                if(curr.__implements)
+                {
+                    method = getServantMethodFromInterfaces(curr.__implements, methodName, allInterfaces);
+                }
+                curr = curr.__parent;
+            }
+
+            if(method !== undefined)
+            {
+                //
+                // Add the method to the servant's type.
+                //
+                servantType[methodName] = method;
+            }
+        }
+
+        if(method === undefined)
+        {
+            //
+            // Next check the op table for the servant's type.
+            //
+            var op;
+            if(servantType.__ops)
+            {
+                op = servantType.__ops.find(name);
+            }
+
+            var source;
+            if(op === undefined)
+            {
+                //
+                // Now check the op tables of the base types.
+                //
+                var parent = servantType.__parent;
+                while(op === undefined && parent)
+                {
+                    if(parent.__ops)
+                    {
+                        if((op = parent.__ops.find(name)) !== undefined)
+                        {
+                            source = parent;
+                        }
+                    }
+                    parent = parent.__parent;
+                }
+
+                //
+                // Now check the op tables of all base interfaces.
+                //
+                for(var i = 0; op === undefined && i < allInterfaces.length; ++i)
+                {
+                    var intf = allInterfaces[i];
+                    if(intf.__ops)
+                    {
+                        if((op = intf.__ops.find(name)) !== undefined)
+                        {
+                            source = intf;
+                        }
+                    }
+                }
+            }
+
+            if(op !== undefined)
+            {
+                method = function(servant, incomingAsync, current)
+                {
+                    return __dispatchImpl(servant, op, incomingAsync, current);
+                };
+
+                //
+                // Add the method to the servant type.
+                //
+                servantType[methodName] = method;
+
+                //
+                // Also add the method to the type in which the operation was found.
+                //
+                if(source)
+                {
+                    source[methodName] = method;
+                }
+            }
+        }
+
+        return method;
+    }
+
+    function addProxyOperation(proxyType, name, data)
+    {
+        var method = data[0] ? data[0] : name;
+
+        var op = null;
+
+        proxyType.prototype[method] = function()
+        {
+            var args = arguments;
+
+            //
+            // Parse the operation data on the first invocation of a proxy method.
+            //
+            if(op === null)
+            {
+                op = parseOperation(name, data);
+            }
+
+            var ctx = args[op.inParams.length]; // The request context is the last argument (if present).
+
+            var marshalFn = null;
+            if(op.inParams.length > 0)
+            {
+                marshalFn = function(os, params)
+                {
+                    marshalParams(os, params, undefined, op.inParams, op.inParamsOpt, op.sendsClasses);
+                };
+            }
+
+            var unmarshalFn = null;
+            if(op.returns || op.outParams.length > 0)
+            {
+                unmarshalFn = function(asyncResult)
+                {
+                    //
+                    // The results array holds the out parameters in the following format:
+                    //
+                    // [retval, out1, out2, ..., asyncResult]
+                    //
+                    var results = [];
+
+                    var is = asyncResult.__startReadParams();
+
+                    var retvalInfo;
+                    if(op.returns && !op.returns.tag)
+                    {
+                        retvalInfo = op.returns;
+                    }
+                    unmarshalParams(is, retvalInfo, op.outParams, op.outParamsOpt, op.returnsClasses, results, 0);
+
+                    asyncResult.__endReadParams();
+
+                    //
+                    // When unmarshaling objects, the ObjectHelper returns a wrapper object
+                    // and eventually stores the unmarshaled object into its "value" member.
+                    // Here we scan the results array and replace the wrappers with the
+                    // actual object references.
+                    //
+                    if(op.returnsClasses || op.outParamsOpt.length > 0)
+                    {
+                        var offset = 0; // Skip asyncResult in results.
+                        if(op.returns && op.returns.isObject && results[op.returns.pos + offset] !== undefined)
+                        {
+                            results[op.returns.pos + offset] = results[op.returns.pos + offset].value;
+                        }
+                        for(var i = 0; i < op.outParams.length; ++i)
+                        {
+                            var p = op.outParams[i];
+                            //
+                            // Optional parameters may be undefined.
+                            //
+                            if(p.isObject && results[p.pos + offset] !== undefined)
+                            {
+                                results[p.pos + offset] = results[p.pos + offset].value;
+                            }
+                        }
+                    }
+                    results.push(asyncResult);
+                    return results;
+                };
+            }
+
+            return Ice.ObjectPrx.__invoke(this, op.name, op.sendMode, op.format, ctx, marshalFn, unmarshalFn,
+                                          op.exceptions, Array.prototype.slice.call(args));
+        };
+    }
+
+    Slice.defineOperations = function(classType, proxyType, ops)
+    {
+        if(ops)
+        {
+            classType.__ops = new OpTable(ops);
+        }
+
+        classType.prototype.__dispatch = function(incomingAsync, current)
+        {
+            //
+            // Retrieve the dispatch method for this operation.
+            //
+            var method = getServantMethod(classType, current.operation);
+
+            if(method === undefined || typeof(method) !== 'function')
+            {
+                throw new Ice.OperationNotExistException(current.id, current.facet, current.operation);
+            }
+
+            return method.call(method, this, incomingAsync, current);
+        };
+
+        if(ops)
+        {
+            for(var name in ops)
+            {
+                addProxyOperation(proxyType, name, ops[name]);
+            }
+        }
+
+        //
+        // Copy proxy methods from super-interfaces.
+        //
+        if(proxyType.__implements)
+        {
+            for(var intf in proxyType.__implements)
+            {
+                var proto = proxyType.__implements[intf].prototype;
+                for(var f in proto)
+                {
+                    if(typeof proto[f] == "function" && proxyType.prototype[f] === undefined)
+                    {
+                        proxyType.prototype[f] = proto[f];
+                    }
+                }
+            }
+        }
+    };
+
+    //
+    // Define the "built-in" operations for all Ice objects.
+    //
+    Slice.defineOperations(Ice.Object, Ice.ObjectPrx,
+    {
+        "ice_ping": [, 1, 1, , , , , , ],
+        "ice_isA": [, 1, 1, , , [1], [[7]], , ],
+        "ice_id": [, 1, 1, , , [7], , , ],
+        "ice_ids": [, 1, 1, , , ["Ice.StringSeqHelper"], , , ]
+    });
+
+    global.Slice = Slice;
+    global.Ice = Ice;
+    
+    /*jshint +W069 */
+}(typeof (global) === "undefined" ? window : global));