• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1// Copyright 2014 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5var createClassWrapper = requireNative('utils').createClassWrapper;
6var nativeDeepCopy = requireNative('utils').deepCopy;
7var schemaRegistry = requireNative('schema_registry');
8var CHECK = requireNative('logging').CHECK;
9var WARNING = requireNative('logging').WARNING;
10
11/**
12 * An object forEach. Calls |f| with each (key, value) pair of |obj|, using
13 * |self| as the target.
14 * @param {Object} obj The object to iterate over.
15 * @param {function} f The function to call in each iteration.
16 * @param {Object} self The object to use as |this| in each function call.
17 */
18function forEach(obj, f, self) {
19  for (var key in obj) {
20    if ($Object.hasOwnProperty(obj, key))
21      $Function.call(f, self, key, obj[key]);
22  }
23}
24
25/**
26 * Assuming |array_of_dictionaries| is structured like this:
27 * [{id: 1, ... }, {id: 2, ...}, ...], you can use
28 * lookup(array_of_dictionaries, 'id', 2) to get the dictionary with id == 2.
29 * @param {Array.<Object.<string, ?>>} array_of_dictionaries
30 * @param {string} field
31 * @param {?} value
32 */
33function lookup(array_of_dictionaries, field, value) {
34  var filter = function (dict) {return dict[field] == value;};
35  var matches = array_of_dictionaries.filter(filter);
36  if (matches.length == 0) {
37    return undefined;
38  } else if (matches.length == 1) {
39    return matches[0]
40  } else {
41    throw new Error("Failed lookup of field '" + field + "' with value '" +
42                    value + "'");
43  }
44}
45
46function loadTypeSchema(typeName, defaultSchema) {
47  var parts = $String.split(typeName, '.');
48  if (parts.length == 1) {
49    if (defaultSchema == null) {
50      WARNING('Trying to reference "' + typeName + '" ' +
51              'with neither namespace nor default schema.');
52      return null;
53    }
54    var types = defaultSchema.types;
55  } else {
56    var schemaName = $Array.join($Array.slice(parts, 0, parts.length - 1), '.');
57    var types = schemaRegistry.GetSchema(schemaName).types;
58  }
59  for (var i = 0; i < types.length; ++i) {
60    if (types[i].id == typeName)
61      return types[i];
62  }
63  return null;
64}
65
66/**
67 * Takes a private class implementation |cls| and exposes a subset of its
68 * methods |functions| and properties |properties| and |readonly| in a public
69 * wrapper class that it returns. Within bindings code, you can access the
70 * implementation from an instance of the wrapper class using
71 * privates(instance).impl, and from the implementation class you can access
72 * the wrapper using this.wrapper (or implInstance.wrapper if you have another
73 * instance of the implementation class).
74 * @param {string} name The name of the exposed wrapper class.
75 * @param {Object} cls The class implementation.
76 * @param {{superclass: ?Function,
77 *          functions: ?Array.<string>,
78 *          properties: ?Array.<string>,
79 *          readonly: ?Array.<string>}} exposed The names of properties on the
80 *     implementation class to be exposed. |superclass| represents the
81 *     constructor of the class to be used as the superclass of the exposed
82 *     class; |functions| represents the names of functions which should be
83 *     delegated to the implementation; |properties| are gettable/settable
84 *     properties and |readonly| are read-only properties.
85 */
86function expose(name, cls, exposed) {
87  var publicClass = createClassWrapper(name, cls, exposed.superclass);
88
89  if ('functions' in exposed) {
90    $Array.forEach(exposed.functions, function(func) {
91      publicClass.prototype[func] = function() {
92        var impl = privates(this).impl;
93        return $Function.apply(impl[func], impl, arguments);
94      };
95    });
96  }
97
98  if ('properties' in exposed) {
99    $Array.forEach(exposed.properties, function(prop) {
100      $Object.defineProperty(publicClass.prototype, prop, {
101        enumerable: true,
102        get: function() {
103          return privates(this).impl[prop];
104        },
105        set: function(value) {
106          var impl = privates(this).impl;
107          delete impl[prop];
108          impl[prop] = value;
109        }
110      });
111    });
112  }
113
114  if ('readonly' in exposed) {
115    $Array.forEach(exposed.readonly, function(readonly) {
116      $Object.defineProperty(publicClass.prototype, readonly, {
117        enumerable: true,
118        get: function() {
119          return privates(this).impl[readonly];
120        },
121      });
122    });
123  }
124
125  return publicClass;
126}
127
128/**
129 * Returns a deep copy of |value|. The copy will have no references to nested
130 * values of |value|.
131 */
132function deepCopy(value) {
133  return nativeDeepCopy(value);
134}
135
136exports.forEach = forEach;
137exports.loadTypeSchema = loadTypeSchema;
138exports.lookup = lookup;
139exports.expose = expose;
140exports.deepCopy = deepCopy;
141