Add handlers to the registry.
@param {Object} map
@returns {Delegator}
169826
function (map) {
        Object.keys(map).forEach(function (key) {
            if (!this.registry.hasOwnProperty(key)) {
                this.registry[key] = map[key];
            }
        }, this);
        return this;
    }
872349
public JsHandlerRegistration addGeometryEditResumeHandler(final GeometryEditResumeHandler handler) {
		org.geomajas.plugin.editing.client.event.GeometryEditResumeHandler h;
		h = new org.geomajas.plugin.editing.client.event.GeometryEditResumeHandler() {

			public void onGeometryEditResume(GeometryEditResumeEvent event) {
				handler.onGeometryEditResume(new org.geomajas.plugin.editing.jsapi.client.event.GeometryEditResumeEvent(
						event.getGeometry()));
			}
		};
		return new JsHandlerRegistration(new HandlerRegistration[] { delegate.addGeometryEditResumeHandler(h) });
	}
79088
function createLoader(handlers) {
  let _handlersType = t.nullable(t.object());

  t.param("handlers", _handlersType).assert(handlers);

  const handlerMap = new Map(Object.keys(handlers).map(key => [key, handlers[key]]));
  handlers = _handlersType.assert(undefined);

  return (state, data) => {
    const keys = Object.keys(data);
    return Promise.all(keys.map(key => {
      const handler = handlerMap.get(key);
      if (!handler) throw new Error(`Missing handler for "${key}".`);
      return handler(state, data[key]);
    })).then(results => {
      const data = Object.create(null);
      results.forEach((result, index) => {
        data[keys[index]] = result;
      });
      return data;
    });
  };
}
306709
public void putAll(Map<? extends K, ? extends V> map) {
    for (Map.Entry<? extends K, ? extends V> e : map.entrySet()) {
      addEntry(e.getKey(), e.getValue());
    }
  }
1193273
function(map) {
        OpenLayers.Layer.HTTPRequest.prototype.setMap.call(this, map);
        OpenLayers.Element.addClass(this.div, this.className);
    }
827636
function (name, method) {
        // TODO: deal with registerPriority in 3.0
        this.map.events.registerPriority(name, this, method);
        this.map.events.registerPriority(name, this, this.setEvent);
    }
1365379
function _assign (maps) {
  let result = new Map()
  for (let m of maps) {
    for (let [key, value] of m) {
      if (result.has(key)) result.delete(key)
      result.set(key, value)
    }
  }
  return result
}
4723
function add( key, value ) {
		var desc;
		switch ( typeof value ) {
			case 'object'   : desc = util.type( value ) == 'descriptor' ? value : util.describe( { value : value }, 'cw' );          break;
			case 'function' : desc = util.describe( make_method( 'parent', value, get_method_descriptor( this, key ), key ), 'cw' ); break;
			default         : desc = util.describe( value, 'cew' );
		}
		util.def( this, key, desc, true );
		return this.constructor;
	}
162133
function(map) {
        this.map = map;
        this.cache = {};
        map.events.register("mousedown", this, this.start, {extension: true});
        map.events.register("mouseup", this, this.onClick, {extension: true});
        map.events.register("touchstart", this, this.start, {extension: true});
        map.events.register("touchmove", this, this.cancel, {extension: true});
        map.events.register("touchend", this, this.onClick, {extension: true});
        map.events.register("mousemove", this, this.onMousemove, {extension: true});
    }
755800
public void setHeaders(Map<String, String> map) {
        headers = new MetadataMap<String, String>();
        for (Map.Entry<String, String> entry : map.entrySet()) {
            String[] values = entry.getValue().split(",");
            for (String v : values) {
                if (v.length() != 0) {
                    headers.add(entry.getKey(), v);
                }
            }
        }
    }
1287317
function(projection, map) {
    Dispatcher.dispatch({
      type: Constants.MAP_PROJECTION,
      projection: projection,
      map: map
    });
  }
5779
@Override
    public T addHandlers(ArchiveEventHandler... handlers) {
        for (ArchiveEventHandler handler : handlers) {
            this.getArchive().addHandlers(handler);
        }
        return covarientReturn();
    }
220550
function(key) {
        this._removeAddsOrRemoves(this.maps.modify, key);
        if (this.maps.remove.indexOf(key) === -1) {
            this.maps.remove.push(key);
        }
        return this;
    }
573895
function (callback) {
      this.recognizer.delegate = this.delegate;

      this.recognizer.map(callback, function (recognizer, routes) {
        for (var i = routes.length - 1, proceed = true; i >= 0 && proceed; --i) {
          var route = routes[i];
          recognizer.add(routes, { as: route.handler });
          proceed = route.path === '/' || route.path === '' || route.handler.slice(-6) === '.index';
        }
      });
    }
1123576
public void registerHandler(String method, String url, OphApiHandler handler) {
		if (mtdHandler == null)
			mtdHandler = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);

		TreeMap<String, OphApiHandler> reg;
		if (method == null)
			method = "ALL";
		reg = mtdHandler.get(method);
		if (reg == null) {
			reg = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
			mtdHandler.put(method, reg);
		}
		reg.put(url, handler);
	}
987478
function addResourceToMap(map, def, start) {
    var sched = JSON.parse(JSON.stringify(def.available || defaultSched)),
        nextFn = schedule.memoizedRangeFn(later.schedule(sched).nextRange);

    map[def.id] = { schedule: sched, next: nextFn, nextAvail: nextFn(start) };
  }
45874
public M put(Map<String, Object> map) {
		attrs.putAll(map);
		return (M)this;
	}